Array Rotation Techniques in DSA Java - Build from Scratch

Array Rotation Techniques

📖 Scenario: You are working on a simple program that helps rotate the positions of items in a list. Imagine a circular queue where the first person moves to the end after their turn. This is useful in games, scheduling, and many other real-life situations.

🎯 Goal: Build a Java program that rotates an array of integers to the right by a given number of steps. You will create the array, set the number of rotations, perform the rotation, and then print the rotated array.

📋 What You'll Learn

Create an integer array called numbers with these exact values: 10, 20, 30, 40, 50

Create an integer variable called rotationSteps and set it to 2

Write a method called rotateRight that takes the numbers array and rotationSteps as parameters and rotates the array to the right by that many steps

Print the rotated array elements separated by spaces

💡 Why This Matters

🌍 Real World

Rotating arrays is useful in scheduling tasks, games where players take turns, and data buffering systems.

💼 Career

Understanding array rotation helps in solving problems related to circular queues, buffers, and cyclic data processing in software development.

1

Create the initial array

Create an integer array called numbers with these exact values: 10, 20, 30, 40, 50

DSA Java

# Create the integer array numbers with values 10, 20, 30, 40, 50
// Your code here

Hint

Use int[] numbers = {10, 20, 30, 40, 50}; to create the array.

2

Set the number of rotation steps

Create an integer variable called rotationSteps and set it to 2

DSA Java

public class Main {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        // Create rotationSteps variable and set it to 2
        // Your code here
    }
}

Hint

Use int rotationSteps = 2; to set the number of steps.

3

Write the rotation method

Write a method called rotateRight that takes the numbers array and rotationSteps as parameters and rotates the array to the right by that many steps. Use a temporary array to store rotated values and copy them back.

DSA Java

public class Main {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        int rotationSteps = 2;
        // Call rotateRight method here
        // Your code here
    }

    // Define rotateRight method here
    // Your code here
}

Hint

Use a temporary array to hold rotated values. Calculate new index as (i + steps) % n. Copy back to original array.

4

Print the rotated array

Print the rotated array elements separated by spaces using a for loop with variable i iterating from 0 to numbers.length.

DSA Java

public class Main {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        int rotationSteps = 2;
        rotateRight(numbers, rotationSteps);
        // Print rotated array elements separated by spaces
        // Your code here
    }

    public static void rotateRight(int[] arr, int steps) {
        int n = arr.length;
        int[] temp = new int[n];
        for (int i = 0; i < n; i++) {
            temp[(i + steps) % n] = arr[i];
        }
        for (int i = 0; i < n; i++) {
            arr[i] = temp[i];
        }
    }
}

Hint

Use a for loop to print each element followed by a space.

Practice

1. What does rotating an array to the left by 1 position mean?
Example: [1, 2, 3, 4] rotated left by 1 becomes?

easy

A. [2, 3, 4, 1]

B. [4, 1, 2, 3]

C. [1, 4, 3, 2]

D. [3, 4, 1, 2]

Solution

1. Step 1: Understand left rotation

   Left rotation by 1 means each element moves one step to the left, and the first element moves to the end.

2. Step 2: Apply left rotation on example

   For [1, 2, 3, 4], after left rotation by 1, it becomes [2, 3, 4, 1].

3. Final Answer:

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

4. Quick Check:

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

Hint: Left rotate shifts elements left, first goes to last [OK]

Common Mistakes:

• Confusing left rotation with right rotation
• Not moving the first element to the end
• Shifting elements in the wrong direction

2. Which of the following Java code snippets correctly rotates an array arr of length n to the right by 1 position?

easy

A. int last = arr[n-1]; for(int i = n-1; i > 0; i--) arr[i] = arr[i-1]; arr[0] = last;

B. int first = arr[0]; for(int i = 0; i < n-1; i++) arr[i] = arr[i+1]; arr[n-1] = first;

C. for(int i = 0; i < n; i++) arr[i] = arr[(i+1) % n];

D. int temp = arr[0]; arr[0] = arr[n-1]; arr[n-1] = temp;

Solution

1. Step 1: Understand right rotation by 1

   Right rotation by 1 moves each element one step right, last element moves to first position.

2. Step 2: Check code correctness

   int last = arr[n-1]; for(int i = n-1; i > 0; i--) arr[i] = arr[i-1]; arr[0] = last; saves last element, shifts elements right, then sets first element to saved last. This matches right rotation.

3. Final Answer:

   int last = arr[n-1]; for(int i = n-1; i > 0; i--) arr[i] = arr[i-1]; arr[0] = last; -> Option A

4. Quick Check:

   Right rotate shifts right, last to first [OK]

Hint: Right rotate moves last element to front [OK]

Common Mistakes:

• Using left rotation logic for right rotation
• Incorrect loop direction causing overwrite
• Swapping only first and last elements

3. What is the output of the following Java code?

int[] arr = {10, 20, 30, 40, 50};
int d = 2;
for(int i = 0; i < d; i++) {
    int temp = arr[0];
    for(int j = 0; j < arr.length - 1; j++) {
        arr[j] = arr[j+1];
    }
    arr[arr.length - 1] = temp;
}
System.out.println(java.util.Arrays.toString(arr));

medium

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

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

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

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

Solution

1. Step 1: Understand the loop rotates array left by 1, repeated d times

   Each iteration moves first element to end, shifting left by 1. Loop runs twice (d=2).

2. Step 2: Trace array after each rotation

   After 1st rotation: [20, 30, 40, 50, 10]
   After 2nd rotation: [30, 40, 50, 10, 20]

3. Final Answer:

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

4. Quick Check:

   Left rotate by 2 shifts first 2 elements to end [OK]

Hint: Left rotate by d moves first d elements to end [OK]

Common Mistakes:

• Confusing left and right rotation
• Not repeating rotation d times
• Off-by-one errors in loops

4. Identify the error in this Java code that attempts to rotate an array arr of length n to the left by 1:

int temp = arr[0];
for(int i = 0; i < n; i++) {
    arr[i] = arr[i+1];
}
arr[n-1] = temp;

medium

A. temp should be assigned after the loop

B. Array length n is incorrect

C. Loop runs out of bounds accessing arr[n]

D. No error, code is correct

Solution

1. Step 1: Analyze the loop range and array access

   The loop runs from i=0 to i=n-1, but inside it accesses arr[i+1]. For i=n-1, arr[i+1] = arr[n], which is out of bounds.

2. Step 2: Identify the cause of error

   Accessing arr[n] causes ArrayIndexOutOfBoundsException. The loop should run only till i < n-1.

3. Final Answer:

   Loop runs out of bounds accessing arr[n] -> Option C

4. Quick Check:

   Array index must be within 0 to n-1 [OK]

Hint: Check array indices carefully to avoid out-of-bounds [OK]

Common Mistakes:

• Looping till i < n instead of i < n-1
• Ignoring array length limits
• Misplacing temp assignment

5. Given an array arr = [5, 10, 15, 20, 25, 30], how can you rotate it to the right by 3 positions efficiently without using extra space?

hard

A. Swap elements pairwise from start to end 3 times

B. Shift elements one by one to the right 3 times using nested loops

C. Copy last 3 elements to a temp array, shift rest right, then copy temp to front

D. Reverse entire array, reverse first 3 elements, then reverse remaining elements

Solution

1. Step 1: Understand the reversal algorithm for rotation

   To rotate right by d, reverse whole array, then reverse first d elements, then reverse remaining n-d elements.

2. Step 2: Apply to example

   Array: [5,10,15,20,25,30]
   Reverse all: [30,25,20,15,10,5]
   Reverse first 3: [20,25,30,15,10,5]
   Reverse last 3: [20,25,30,5,10,15]

3. Final Answer:

   Reverse entire array, reverse first 3 elements, then reverse remaining elements -> Option D

4. Quick Check:

   Reversal method rotates array efficiently without extra space [OK]

Hint: Use reversal method: reverse all, then parts [OK]

Common Mistakes:

• Using extra space instead of in-place reversal
• Shifting elements one by one inefficiently
• Incorrect order of reversals