Array Reversal Techniques in DSA Rust - Execution Trace

Concept Flow - Array Reversal Techniques

Start with array

↓

Set left = 0, right = length-1

↓

Check if 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 or cross.

Execution Sample

DSA Rust

let mut arr = [1, 2, 3, 4, 5];
let mut left = 0;
let mut right = arr.len() - 1;
while left < right {
    arr.swap(left, right);
    left += 1;
    right -= 1;
}

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

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	Check left < right	0	4	[1, 2, 3, 4, 5]	0 < 4 is True
3	Swap arr[left] and arr[right]	0	4	[5, 2, 3, 4, 1]	Swapped arr[0] and arr[4]
4	Increment left, Decrement right	1	3	[5, 2, 3, 4, 1]	left=1, right=3
5	Check left < right	1	3	[5, 2, 3, 4, 1]	1 < 3 is True
6	Swap arr[left] and arr[right]	1	3	[5, 4, 3, 2, 1]	Swapped arr[1] and arr[3]
7	Increment left, Decrement right	2	2	[5, 4, 3, 2, 1]	left=2, right=2
8	Check left < right	2	2	[5, 4, 3, 2, 1]	2 < 2 is False
9	Exit loop	2	2	[5, 4, 3, 2, 1]	Reversal complete

💡 left is not less than right (2 < 2 is False), loop ends

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 6	After Step 7	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 the loop when left is not less than right?

Because when left equals or passes right, all elements have been swapped. See execution_table step 8 where 2 < 2 is False, so no more swaps are needed.

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

The middle element stays in place because left and right meet at the same index without swapping. In step 7 and 8, left and right both become 2, so the middle element arr[2] remains unchanged.

Why do we swap elements at left and right instead of just reversing by copying?

Swapping in place saves memory by not needing extra space. The execution_table shows swaps at steps 3 and 6, changing the array directly.

Visual Quiz - 3 Questions

Look at the execution_table at step 6, what is the array state?

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

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

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

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

💡 Hint

Check the 'Array State' column at step 6 in execution_table

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

A Step 7

B Step 9

C Step 8

D Step 6

💡 Hint

Look at the 'Pointer Changes' column for the condition check in execution_table

If the array length was 6 instead of 5, how many swaps would happen?

A 2 swaps

B 3 swaps

C 5 swaps

D 6 swaps

💡 Hint

Number of swaps is half the array length, see how 5 elements had 2 swaps in variable_tracker

Concept Snapshot

Array Reversal Technique:
- Use two pointers: left at start, right at end
- While left < right, swap elements at left and right
- Move left forward, right backward
- Stop when pointers meet or cross
- Works in-place, no extra memory needed

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 index 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 is no longer less than right, the array is reversed. The execution table traces each step, showing pointer positions and array state. Key moments clarify why the loop stops and how odd-length arrays keep the middle element unchanged. The quiz tests understanding of array state at specific steps and the number of swaps needed.

Practice

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

easy

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

B. Sorting the array in ascending order

C. Removing duplicate elements from the array

D. Adding new elements to the end of the array

Solution

1. Step 1: Understand array reversal

   Reversing means flipping the order of elements so the last element comes first and the first element goes last.

2. Step 2: Compare with other options

   Sorting arranges elements by value, removing duplicates deletes repeats, and adding elements is insertion, not reversal.

3. Final Answer:

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

4. Quick Check:

   Reversal = Flip order [OK]

Hint: Reversal flips order, not sorting or adding [OK]

Common Mistakes:

• Confusing reversal with sorting
• Thinking reversal removes elements
• Mixing reversal with adding elements

2. Which of the following Rust code snippets correctly reverses a mutable array arr in place?

easy

A. arr = arr.reverse();

B. arr.reverse();

C. arr.reverse(&mut arr);

D. reverse(arr);

Solution

1. Step 1: Identify correct method usage

   In Rust, the reverse() method is called directly on a mutable slice or array as arr.reverse(); to reverse it in place.

2. Step 2: Check other options for errors

   arr = arr.reverse(); tries to assign the result of reverse() which returns (), so it's invalid. arr.reverse(&mut arr); passes &mut arr as argument, but reverse() takes no arguments. reverse(arr); calls a function reverse which is undefined.

3. Final Answer:

   arr.reverse(); -> Option B

4. Quick Check:

   Use method directly on mutable array [OK]

Hint: Use arr.reverse() without assignment or arguments [OK]

Common Mistakes:

• Assigning reverse() result to array
• Passing array as argument to reverse()
• Calling undefined reverse function

3. What will be the output of this Rust code?

let mut arr = [1, 2, 3, 4, 5];
arr.reverse();
println!("{:?}", arr);

medium

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

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

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

D. Compilation error

Solution

1. Step 1: Understand reverse() effect on array

   The reverse() method reverses the array elements in place, so the order becomes last to first.

2. Step 2: Apply reverse to given array

   Original array is [1, 2, 3, 4, 5]. After reversal, it becomes [5, 4, 3, 2, 1].

3. Final Answer:

   [5, 4, 3, 2, 1] -> Option C

4. Quick Check:

   Reverse flips array order [OK]

Hint: Reverse flips array elements order [OK]

Common Mistakes:

• Expecting original order after reverse
• Thinking reverse sorts array
• Confusing output format

4. Identify the error in this Rust code that tries to reverse an array:

let arr = [10, 20, 30, 40];
arr.reverse();

medium

A. Cannot call reverse() on an immutable array

B. reverse() method does not exist for arrays

C. Missing semicolon after array declaration

D. reverse() requires an argument

Solution

1. Step 1: Check mutability of array

   The array arr is declared immutable by default with let. The reverse() method requires a mutable array.

2. Step 2: Understand method requirements

   To reverse in place, the array must be mutable, declared as let mut arr. Otherwise, calling reverse() causes a compile error.

3. Final Answer:

   Cannot call reverse() on an immutable array -> Option A

4. Quick Check:

   reverse() needs mutable array [OK]

Hint: Make array mutable with 'mut' before reversing [OK]

Common Mistakes:

• Forgetting to add 'mut' to array declaration
• Thinking reverse() needs arguments
• Assuming reverse() is not available for arrays

5. Given a vector vec = vec![1, 2, 3, 4, 5], which code snippet correctly reverses it and returns a new reversed vector without modifying the original?

hard

A. let rev_vec = vec.into_iter().reverse().collect();

B. vec.reverse(); let rev_vec = vec.clone();

C. let rev_vec = vec.reverse();

D. let rev_vec = vec.iter().rev().cloned().collect::();

Solution

1. Step 1: Understand vector reversal without mutation

   To reverse without changing original, use iterator rev() on iter(), clone elements, then collect into new vector.

2. Step 2: Analyze options

   let rev_vec = vec.iter().rev().cloned().collect::(); uses vec.iter().rev().cloned().collect() which creates a new reversed vector. vec.reverse(); let rev_vec = vec.clone(); reverses original vector in place, modifying it. let rev_vec = vec.reverse(); tries to assign reverse() result which is (), invalid. let rev_vec = vec.into_iter().reverse().collect(); uses into_iter() which consumes the original vector, so it doesn't leave the original unmodified.

3. Final Answer:

   let rev_vec = vec.iter().rev().cloned().collect::(); -> Option D

4. Quick Check:

   Use iter().rev().cloned().collect() for new reversed vector [OK]

Hint: Use iter().rev().cloned().collect() for reversed copy [OK]

Common Mistakes:

• Modifying original vector instead of copying
• Assigning reverse() result directly
• Using invalid reverse() on iterator