Array Rotation Techniques in DSA C++ - Time & Space Complexity

Time Complexity: Array Rotation Techniques

O(n * d)

Understanding Time Complexity

We want to understand how the time needed to rotate an array changes as the array gets bigger.

Specifically, we ask: How many steps does it take to move elements around when rotating?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

void rotateArray(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;
    }
}
    

This code rotates the array to the left by d positions by moving elements one by one.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The inner loop shifts elements one position left.
• How many times: The inner loop runs (n - 1) times for each of the d outer loop iterations.

How Execution Grows With Input

As the array size (n) or rotation count (d) grows, the total steps increase roughly by multiplying n and d.

Input Size (n)	Rotation Count (d)	Approx. Operations
10	2	About 18 steps (2 * 9)
100	10	About 990 steps (10 * 99)
1000	100	About 99,900 steps (100 * 999)

Pattern observation: The steps grow roughly like the product of n and d, so doubling either doubles the work.

Final Time Complexity

Time Complexity: O(n * d)

This means the time needed grows proportionally to the array size times the number of rotations.

Common Mistake

[X] Wrong: "Rotating an array by d positions always takes O(n) time regardless of d."

[OK] Correct: Actually, this simple method moves elements one by one d times, so time depends on both n and d.

Interview Connect

Understanding how different rotation methods affect time helps you choose efficient solutions and explain your reasoning clearly.

Self-Check

"What if we used the reversal algorithm for rotation instead? How would the time complexity change?"

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