Array Reversal Techniques in DSA C# - Execution Trace

Concept Flow - Array Reversal Techniques

Start with array

↓

Set left = 0, right = length-1

↓

Check: left < right?

No→Done

Yes↓

Swap elements at left and right

↓

Increment left, Decrement right

↩Back to Check

Start with two pointers at the ends of the array, swap elements, move pointers inward until they meet.

Execution Sample

DSA C#

int[] arr = {1, 2, 3, 4, 5};
int left = 0, right = arr.Length - 1;
while (left < right) {
  int temp = arr[left];
  arr[left] = arr[right];
  arr[right] = temp;
  left++;
  right--;
}

This code reverses the array by swapping elements from the ends moving towards the center.

Execution Table

Step	Operation	left	right	Array State	Pointer Changes
1	Initialize pointers	0	4	[1, 2, 3, 4, 5]	left=0, right=4
2	Swap arr[left] and arr[right]	0	4	[5, 2, 3, 4, 1]	Swap arr[0] and arr[4]
3	Increment left, Decrement right	1	3	[5, 2, 3, 4, 1]	left=1, right=3
4	Swap arr[left] and arr[right]	1	3	[5, 4, 3, 2, 1]	Swap arr[1] and arr[3]
5	Increment left, Decrement right	2	2	[5, 4, 3, 2, 1]	left=2, right=2
6	Check condition left < right	2	2	[5, 4, 3, 2, 1]	2 < 2 is False, stop
Exit	Reversal complete	2	2	[5, 4, 3, 2, 1]	Final reversed array

💡 left equals right (2), condition left < right is False, reversal stops

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	Final
left	0	0	1	1	2	2
right	4	4	3	3	2	2
arr	[1,2,3,4,5]	[5,2,3,4,1]	[5,2,3,4,1]	[5,4,3,2,1]	[5,4,3,2,1]	[5,4,3,2,1]

Key Moments - 3 Insights

Why do we stop when left equals right instead of when left is greater than right?

Because when left equals right, the middle element is reached and does not need swapping. The execution_table row 6 shows the condition left < right is False when left == right, so the loop stops.

Why do we swap elements at left and right pointers?

Swapping arr[left] and arr[right] moves the element from the start to the end and vice versa, reversing the array step by step. See execution_table rows 2 and 4 where swaps happen.

What happens if the array has an odd number of elements?

The middle element stays in place because swapping stops when left meets right. The variable_tracker shows left and right both at 2 for the middle element in a 5-element array.

Visual Quiz - 3 Questions

Look at the execution_table, what is the array state after step 4?

A [5, 4, 3, 2, 1]

B [5, 2, 3, 4, 1]

C [1, 2, 3, 4, 5]

D [1, 4, 3, 2, 5]

💡 Hint

Check the 'Array State' column at step 4 in the execution_table.

At which step does the condition left < right become false?

A Step 5

B Step 4

C Step 6

D Step 3

💡 Hint

Look at the 'Operation' and 'Pointer Changes' columns at step 6 in the execution_table.

If the array length was 6 instead of 5, what would be the final values of left and right?

A left=2, right=3

B left=3, right=2

C left=3, right=3

D left=2, right=2

💡 Hint

For even length arrays, left passes right when loop ends; check variable_tracker pattern.

Concept Snapshot

Array Reversal Technique:
- Use two pointers: left at start, right at end
- Swap elements at left and right
- Move left forward, right backward
- Repeat until left >= right
- Works for arrays of any length
- In-place reversal with O(1) extra space

Full Transcript

This visualization shows how to reverse an array by swapping elements from the ends moving inward. We start with two pointers, left at 0 and right at the last index. While left is less than right, we swap the elements at these positions, then move left forward and right backward. When left meets or passes right, the array is reversed. The execution table tracks each step, showing the array state and pointer changes. Key moments clarify why the loop stops when pointers meet and how odd-length arrays keep the middle element unchanged. The visual quiz tests understanding of array states and pointer positions during reversal.

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