Array Rotation Techniques in DSA C++ - Execution Trace

Concept Flow - Array Rotation Techniques

Start with array

↓

Choose rotation direction

↓

Left Rotate

↓

Select method

↓

Using temp array

↓

Perform rotation steps

↓

Result: rotated array

Start with an array, choose left or right rotation, pick a method like temp array or reversal, perform steps, and get the rotated array.

Execution Sample

DSA C++

int arr[] = {1,2,3,4,5};
int n = 5, d = 2;
// Left rotate by 2 using reversal method
reverse(arr, arr + d);
reverse(arr + d, arr + n);
reverse(arr, arr + n);

This code left rotates the array by 2 positions using the reversal method.

Execution Table

Step	Operation	Array State	Pointer Changes	Visual State
1	Initial array	[1, 2, 3, 4, 5]	head=0, d=2, n=5	1 -> 2 -> 3 -> 4 -> 5 -> null
2	Reverse first d elements	[2, 1, 3, 4, 5]	reverse indices 0 to 1	2 -> 1 -> 3 -> 4 -> 5 -> null
3	Reverse remaining elements	[2, 1, 5, 4, 3]	reverse indices 2 to 4	2 -> 1 -> 5 -> 4 -> 3 -> null
4	Reverse whole array	[3, 4, 5, 1, 2]	reverse indices 0 to 4	3 -> 4 -> 5 -> 1 -> 2 -> null
5	Rotation complete	[3, 4, 5, 1, 2]	final array	3 -> 4 -> 5 -> 1 -> 2 -> null
6	Exit	Rotation done	-	-

💡 Rotation complete after reversing parts and whole array

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
arr	[1,2,3,4,5]	[2,1,3,4,5]	[2,1,5,4,3]	[3,4,5,1,2]	[3,4,5,1,2]
d	2	2	2	2	2
n	5	5	5	5	5

Key Moments - 3 Insights

Why do we reverse parts of the array instead of shifting elements one by one?

Reversing parts reduces the number of moves. Instead of shifting elements multiple times, reversal rearranges segments efficiently as shown in steps 2-4 of the execution_table.

Why do we reverse the whole array at the end?

Reversing the whole array after reversing parts puts elements in the correct rotated order. Step 4 shows this final reversal that completes the rotation.

What happens if rotation count d is zero or equal to array size?

If d is 0 or equal to n, the array remains unchanged. The reversal steps would not alter the array, so the final state matches the initial state.

Visual Quiz - 3 Questions

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

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

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

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

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

💡 Hint

Check the 'Array State' column for step 3 in the execution_table.

At which step does the array become fully rotated?

A Step 2

B Step 4

C Step 5

D Step 3

💡 Hint

Look for the 'Rotation complete' operation in the execution_table.

If d was 0, how would the array state change after step 2?

A Array reversed fully

B Array remains the same

C First element swapped with last

D Array partially reversed

💡 Hint

Refer to key_moments about what happens when d=0.

Concept Snapshot

Array Rotation Techniques:
- Rotate array left or right by d positions
- Reversal method: reverse first d, reverse rest, then reverse whole
- Efficient: avoids shifting elements one by one
- Works in-place with O(n) time and O(1) space
- Handles d=0 or d=n as no rotation

Full Transcript

Array rotation means moving elements left or right by a number of positions. The reversal method rotates by reversing parts of the array and then the whole array. This reduces moves compared to shifting elements one by one. For example, rotating left by 2 on [1,2,3,4,5] reverses first two elements to [2,1,3,4,5], then reverses last three to [2,1,5,4,3], and finally reverses the whole array to get [3,4,5,1,2]. If rotation count is zero or equal to array size, the array stays the same. This method is efficient and done in-place.

Practice

1. What does rotating an array to the left by 1 position do to the elements?

easy

A. Moves the last element to the front and shifts all others one position right

B. Moves the first element to the end and shifts all others one position left

C. Reverses the entire array

D. Sorts the array in ascending order

Solution

1. Step 1: Understand left rotation by 1

   Left rotation by 1 means the element at index 0 moves to the end.

2. Step 2: Effect on other elements

   All other elements shift one position to the left to fill the gap.

3. Final Answer:

   Moves the first element to the end and shifts all others one position left -> Option B

4. Quick Check:

   Left rotate by 1 = first element moves to end [OK]

Hint: Left rotate by 1 moves front element to back [OK]

Common Mistakes:

• Confusing left rotation with right rotation
• Thinking rotation reverses the array
• Assuming rotation sorts the array

2. Which of the following is the correct syntax to rotate an array arr of size n to the right by 1 position in C++?

easy

A. std::rotate(arr, arr + n, arr + 1);

B. std::rotate(arr, arr + 1, arr + n);

C. std::rotate(arr, arr + n - 1, arr + n);

D. std::rotate(arr + 1, arr, arr + n);

Solution

1. Step 1: Understand std::rotate parameters

   std::rotate takes three pointers: first, middle, last. It rotates the range [first, last) so that the element at middle becomes first.

2. Step 2: Rotate right by 1 means last element moves to front

   To rotate right by 1, middle should point to the last element (arr + n - 1).

3. Final Answer:

   std::rotate(arr, arr + n - 1, arr + n); -> Option C

4. Quick Check:

   Right rotate by 1 uses middle = last-1 [OK]

Hint: Right rotate by 1 uses middle = last-1 in std::rotate [OK]

Common Mistakes:

• Using middle = first + 1 for right rotation
• Swapping parameters order incorrectly
• Confusing rotate range boundaries

3. What is the output of the following C++ code?

int arr[] = {10, 20, 30, 40, 50};
int n = 5;
int d = 2;
std::rotate(arr, arr + d, arr + n);
for(int i = 0; i < n; i++) std::cout << arr[i] << " ";

medium

A. 30 40 50 10 20

B. 40 50 10 20 30

C. 50 10 20 30 40

D. 20 30 40 50 10

Solution

1. Step 1: Understand std::rotate with d=2

   std::rotate(arr, arr + 2, arr + 5) moves elements starting from index 2 to front.

2. Step 2: Rearrange array after rotation

   Elements from index 2 to 4: 30, 40, 50 come first, then elements from index 0 to 1: 10, 20.

3. Final Answer:

   30 40 50 10 20 -> Option A

4. Quick Check:

   Rotate left by 2 shifts first 2 elements to end [OK]

Hint: Rotate left by d moves first d elements to end [OK]

Common Mistakes:

• Confusing left and right rotation
• Off-by-one errors in index calculation
• Printing array before rotation

4. The following code is intended to rotate an array arr of size n to the left by d positions. What is the error?

void rotateLeft(int arr[], int n, int d) {
    for(int i = 0; i < d; i++) {
        int temp = arr[0];
        for(int j = 0; j < n - 1; j++) {
            arr[j] = arr[j+1];
        }
        arr[n - 1] = temp;
    }
}

medium

A. temp should be assigned arr[n-1] instead of arr[0]

B. Inner loop should run from j=1 to n-1

C. The outer loop should run from i=1 to d

D. Accessing arr[n] causes out-of-bounds error

Solution

1. Step 1: Analyze inner loop index usage

   The inner loop runs j from 0 to n-1, but accesses arr[j+1]. When j = n-1, arr[j+1] = arr[n] is accessed.

2. Step 2: Identify out-of-bounds access

   Array indices go from 0 to n-1, so arr[n] is invalid and causes out-of-bounds error.

3. Final Answer:

   Accessing arr[n] causes out-of-bounds error -> Option D

4. Quick Check:

   Array index out of bounds at arr[n] [OK]

Hint: Array indices go 0 to n-1, arr[n] is invalid [OK]

Common Mistakes:

• Ignoring out-of-bounds access
• Misunderstanding loop ranges
• Incorrectly assigning temp value

5. Given an array arr = {1, 2, 3, 4, 5, 6, 7} and d = 3, which sequence of operations correctly rotates the array to the left by d positions using the reversal algorithm?

hard

A. Reverse first d elements, reverse last n-d elements, then reverse whole array

B. Reverse whole array, reverse first d elements, then reverse last n-d elements

C. Reverse first d elements, reverse whole array, then reverse last n-d elements

D. Reverse whole array, reverse last n-d elements, then reverse first d elements

Solution

1. Step 1: Understand reversal algorithm steps

   To rotate left by d, first reverse the first d elements.

2. Step 2: Reverse last n-d elements, then reverse whole array

   Next reverse the last n-d elements, finally reverse the entire array to get the rotated result.

3. Final Answer:

   Reverse first d elements, reverse last n-d elements, then reverse whole array -> Option A

4. Quick Check:

   Reversal algorithm order = first d, last n-d, whole [OK]

Hint: Left rotate reversal: first d, last n-d, then whole [OK]

Common Mistakes:

• Reversing parts before whole array
• Mixing order of reversing segments
• Confusing left and right rotation steps