Array Reversal Techniques in DSA C#

Mental Model

Reversing an array means flipping its order so the last element becomes first and the first becomes last.

Analogy: Imagine a row of books on a shelf. Reversing the array is like taking the books from both ends and swapping them until you meet in the middle.

Original array:
[1] -> [2] -> [3] -> [4] -> [5]

Reversed array:
[5] -> [4] -> [3] -> [2] -> [1]

Dry Run Walkthrough

Input: array: [1, 2, 3, 4, 5]

Goal: Reverse the array so it becomes [5, 4, 3, 2, 1]

Step 1: Swap first element (1) with last element (5)

[5] -> [2] -> [3] -> [4] -> [1]

Why: Swap ends to start reversing order

Step 2: Swap second element (2) with second last element (4)

[5] -> [4] -> [3] -> [2] -> [1]

Why: Continue swapping inward to reverse array

Step 3: Middle element (3) stays the same, reversal complete

[5] -> [4] -> [3] -> [2] -> [1]

Why: Middle element does not need swapping

Result:

[5] -> [4] -> [3] -> [2] -> [1]

Annotated Code

DSA C#

using System;

class ArrayReversal {
    // Function to reverse the array in place
    public static void Reverse(int[] arr) {
        int left = 0;
        int right = arr.Length - 1;
        while (left < right) {
            // Swap elements at left and right
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            // Move pointers inward
            left++;
            right--;
        }
    }

    static void Main() {
        int[] array = {1, 2, 3, 4, 5};
        Reverse(array);
        // Print reversed array
        for (int i = 0; i < array.Length; i++) {
            Console.Write(array[i]);
            if (i < array.Length - 1) Console.Write(" -> ");
        }
        Console.WriteLine();
    }
}

while (left < right) {

Loop until pointers meet or cross to cover all swaps

int temp = arr[left]; arr[left] = arr[right]; arr[right] = temp;

Swap elements at left and right positions

left++; right--;

Move pointers inward to next pair

Output

5 -> 4 -> 3 -> 2 -> 1

Complexity Analysis

Time: O(n) because we swap pairs from both ends and visit each element once

Space: O(1) because reversal is done in place without extra storage

vs Alternative: Naive approach creates a new array and copies elements in reverse order, costing O(n) extra space; this in-place method saves memory

Edge Cases

Empty array

No swaps happen, array remains empty

DSA C#

while (left < right) {

Single element array

No swaps happen, array stays the same

DSA C#

while (left < right) {

Array with duplicate elements

Duplicates are swapped like any other elements, reversal works normally

DSA C#

int temp = arr[left];

When to Use This Pattern

When you need to reverse the order of elements in a list or array efficiently, use the two-pointer swap technique to reverse in place.

Common Mistakes

Mistake: Swapping elements without moving pointers inward, causing infinite loop
Fix: Increment left and decrement right pointers after each swap

Mistake: Swapping elements incorrectly by overwriting without temporary variable
Fix: Use a temporary variable to hold one element during swap

Summary

Reverses the order of elements in an array by swapping pairs from ends inward.

Use when you want to reverse an array efficiently without extra space.

The key is to swap elements from the outside moving inward until pointers meet.

Practice

1. What does reversing an array mean in simple terms?

easy

A. Removing duplicate elements from the array

B. Sorting the array in ascending order

C. Changing the order of elements so the last becomes first and first becomes last

D. Adding new elements at the end of the array

Solution

1. Step 1: Understand array order

   An array has elements arranged from first to last in a sequence.

2. Step 2: Define reversal

   Reversing means swapping elements so the last element moves to the front and the first moves to the end, flipping the order.

3. Final Answer:

   Changing the order of elements so the last becomes first and first becomes last -> Option C

4. Quick Check:

   Reversal = Flip order [OK]

Hint: Reversal flips the array order front to back [OK]

Common Mistakes:

• Confusing reversal with sorting
• Thinking reversal removes elements
• Assuming reversal adds elements

2. Which of the following is the correct syntax to reverse an array named arr in C# using built-in methods?

easy

A. Array.Reverse(arr);

B. arr.Reverse();

C. reverse(arr);

D. arr.reverse();

Solution

1. Step 1: Identify C# array reversal method

   C# provides a static method Array.Reverse() to reverse arrays in place.

2. Step 2: Check syntax correctness

   The correct syntax calls Array.Reverse(arr); with capital 'A' and 'R' and no return value.

3. Final Answer:

   Array.Reverse(arr); -> Option A

4. Quick Check:

   Use Array.Reverse(arr) in C# [OK]

Hint: Use Array.Reverse(arr) to reverse arrays in C# [OK]

Common Mistakes:

• Using lowercase method names
• Calling reverse as instance method on array
• Using non-existent reverse functions

3. What will be the output of the following C# code?

int[] arr = {1, 2, 3, 4, 5};
Array.Reverse(arr);
Console.WriteLine(string.Join(", ", arr));

medium

A. 1, 2, 3, 4, 5

B. 5, 2, 3, 4, 1

C. Syntax Error

D. 5, 4, 3, 2, 1

Solution

1. Step 1: Understand Array.Reverse effect

   The method reverses the array elements in place, so the order flips.

2. Step 2: Trace the output

   Original array: 1, 2, 3, 4, 5 becomes 5, 4, 3, 2, 1 after reversal.

3. Final Answer:

   5, 4, 3, 2, 1 -> Option D

4. Quick Check:

   Reversed array prints 5 to 1 [OK]

Hint: Reversal flips array order exactly [OK]

Common Mistakes:

• Assuming reversal sorts the array
• Expecting original order after reversal
• Confusing output format

4. Identify the error in the following C# code that attempts to reverse an array:

int[] arr = {10, 20, 30};
arr.Reverse();
Console.WriteLine(string.Join(", ", arr));

medium

A. arr.Reverse() does not reverse the array in place

B. Array must be converted to list before reversing

C. Console.WriteLine syntax is incorrect

D. No error, code works fine

Solution

1. Step 1: Check arr.Reverse() method

   In C#, arr.Reverse() returns a reversed sequence but does not change the original array.

2. Step 2: Understand effect on original array

   The original array remains unchanged, so printing it shows original order, not reversed.

3. Final Answer:

   arr.Reverse() does not reverse the array in place -> Option A

4. Quick Check:

   arr.Reverse() returns reversed IEnumerable, no in-place change [OK]

Hint: Array.Reverse(arr) reverses in place; arr.Reverse() does not [OK]

Common Mistakes:

• Assuming arr.Reverse() changes original array
• Confusing LINQ Reverse with Array.Reverse
• Ignoring return value of arr.Reverse()

5. Given an integer array arr with an odd number of elements, which approach correctly reverses the array in place without using built-in methods?

hard

A. Create a new array and copy elements from end to start, then assign back to original array

B. Use two pointers, one at start and one at end, swap elements and move pointers towards center until they meet

C. Sort the array in descending order to reverse it

D. Remove the middle element and reverse the rest of the array

Solution

1. Step 1: Understand in-place reversal with two pointers

   Start with one pointer at the first element and another at the last element, swap their values.

2. Step 2: Move pointers towards center and swap

   Increment the start pointer and decrement the end pointer, continue swapping until pointers meet or cross.

3. Final Answer:

   Use two pointers, one at start and one at end, swap elements and move pointers towards center until they meet -> Option B

4. Quick Check:

   Two-pointer swap reverses array in place [OK]

Hint: Swap start and end elements moving inward [OK]

Common Mistakes:

• Using sorting instead of reversal
• Creating extra arrays unnecessarily
• Removing elements instead of swapping