Array Rotation Techniques in DSA Javascript - Time & Space Complexity

Time Complexity: Array Rotation Techniques

O(n)

Understanding Time Complexity

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

How does the number of steps grow when we rotate more elements?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

function rotateArray(arr, k) {
  const n = arr.length;
  k = k % n;
  const rotated = arr.slice(n - k).concat(arr.slice(0, n - k));
  return rotated;
}
    

This code rotates an array to the right by k steps by slicing and joining parts.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Creating two slices of the array and concatenating them.
• How many times: Each slice goes through part of the array once, so total traversal is the whole array once.

How Execution Grows With Input

As the array size grows, the number of elements copied grows proportionally.

Input Size (n)	Approx. Operations
10	About 10 elements copied
100	About 100 elements copied
1000	About 1000 elements copied

Pattern observation: The work grows linearly with the size of the array.

Final Time Complexity

Time Complexity: O(n)

This means the time to rotate grows directly with the number of elements in the array.

Common Mistake

[X] Wrong: "Rotating an array by k steps takes constant time because we only move k elements."

[OK] Correct: Even if k is small, slicing and concatenating still processes the whole array, so time depends on n, not just k.

Interview Connect

Understanding how array rotation scales helps you explain and choose the best approach in coding challenges and real projects.

Self-Check

"What if we rotated the array in place using reversal steps instead of slicing? How would the time complexity change?"

Practice

1. What does rotating an array to the right by 1 position mean?
arr = [1, 2, 3, 4] rotated right by 1 becomes?

easy

A. [4, 1, 2, 3]

B. [2, 3, 4, 1]

C. [1, 2, 3, 4]

D. [3, 4, 1, 2]

Solution

1. Step 1: Understand right rotation by 1

   Right rotation by 1 means the last element moves to the front, and others shift right.

2. Step 2: Apply to given array

   Last element 4 moves to front, rest shift right: [4, 1, 2, 3].

3. Final Answer:

   [4, 1, 2, 3] -> Option A

4. Quick Check:

   Right rotate by 1 = last element front [OK]

Hint: Last element moves front on right rotation by 1 [OK]

Common Mistakes:

• Confusing left and right rotation
• Shifting elements left instead of right
• Not moving last element to front

2. Which of the following is the correct JavaScript syntax to rotate an array arr to the left by 1 position?

easy

A. arr.unshift(arr.pop())

B. arr.push(arr.shift())

C. arr.pop(arr.unshift())

D. arr.shift(arr.push())

Solution

1. Step 1: Understand left rotation by 1

   Left rotation by 1 means first element moves to the end.

2. Step 2: Match syntax to operation

   arr.shift() removes first element, arr.push() adds it to end. So arr.push(arr.shift()) rotates left by 1.

3. Final Answer:

   arr.push(arr.shift()) -> Option B

4. Quick Check:

   Left rotate = shift then push [OK]

Hint: Left rotate = shift first, then push it back [OK]

Common Mistakes:

• Using pop instead of shift for left rotation
• Using unshift incorrectly
• Mixing push and pop order

3. What is the output of the following code?

const arr = [10, 20, 30, 40, 50];
const k = 2;
const rotated = arr.slice(-k).concat(arr.slice(0, arr.length - k));
console.log(rotated);

medium

A. [40, 50, 10, 20, 30]

B. [30, 40, 50, 10, 20]

C. [50, 10, 20, 30, 40]

D. [20, 30, 40, 50, 10]

Solution

1. Step 1: Understand slicing for right rotation by k=2

   arr.slice(-2) gets last 2 elements: [40, 50]. arr.slice(0, 3) gets first 3 elements: [10, 20, 30].

2. Step 2: Concatenate slices

   Concatenate [40, 50] + [10, 20, 30] = [40, 50, 10, 20, 30].

3. Final Answer:

   [40, 50, 10, 20, 30] -> Option A

4. Quick Check:

   Right rotate by 2 = last 2 front [OK]

Hint: Right rotate by k = last k elements + rest [OK]

Common Mistakes:

• Using slice(0, k) instead of slice(-k)
• Concatenating in wrong order
• Confusing left and right rotation

4. Find the error in this code that tries to rotate an array arr left by k positions:

function rotateLeft(arr, k) {
  for(let i = 0; i < k; i++) {
    arr.unshift(arr.shift());
  }
  return arr;
}

medium

A. Using unshift instead of push inside loop

B. Loop should run from i = 1 to k

C. No error, code works correctly

D. shift() removes last element, should use pop()

Solution

1. Step 1: Analyze loop operation

   Inside loop, arr.shift() removes first element correctly for left rotation.

2. Step 2: Check insertion method

   arr.unshift() adds element to front, which reverses the shift effect. It should be arr.push() to add at end.

3. Final Answer:

   No error, code works correctly -> Option C

4. Quick Check:

   Code rotates left by k positions correctly [OK]

Hint: Left rotate = shift then push, not unshift [OK]

Common Mistakes:

• Using unshift instead of push
• Confusing shift and pop
• Incorrect loop range

5. Given an array arr = [1, 2, 3, 4, 5], how can you rotate it left by k = 7 positions efficiently without extra space?

hard

A. Rotate left by k positions using nested loops

B. Rotate left by k positions directly using slice and concat

C. Rotate right by k positions using pop and unshift

D. Rotate left by k % arr.length = 2 positions using reversal algorithm

Solution

1. Step 1: Calculate effective rotation

   Since k=7 and arr.length=5, effective rotation is k % 5 = 2.

2. Step 2: Use reversal algorithm for in-place rotation

   Reverse first 2 elements, reverse last 3 elements, then reverse whole array to rotate left by 2 efficiently without extra space.

3. Final Answer:

   Rotate left by k % arr.length = 2 positions using reversal algorithm -> Option D

4. Quick Check:

   Use k mod length and reversal for efficient rotation [OK]

Hint: Use k mod array length and reversal for efficient rotation [OK]

Common Mistakes:

• Rotating by k without modulo causes extra rotations
• Using slice creates extra space
• Using nested loops is inefficient