Java Program For Array Rotation

Write a Java Program for a given array of integers arr[] of size N and an integer, the task is to rotate the array elements to the left by d positions.

Examples:

Input: 
arr[] = {1, 2, 3, 4, 5, 6, 7}, d = 2
Output: 3 4 5 6 7 1 2

Input: arr[] = {3, 4, 5, 6, 7, 1, 2}, d=2
Output: 5 6 7 1 2 3 4

Java Program For Array Rotation using temp array:

After rotating d positions to the left, the first d elements become the last d elements of the array

• First store the elements from index d to N-1 into the temp array.
• Then store the first d elements of the original array into the temp array.
• Copy back the elements of the temp array into the original array

Illustration:

Suppose the give array is arr[] = [1, 2, 3, 4, 5, 6, 7], d = 2.

First Step:
    => Store the elements from 2nd index to the last.
    => temp[] = [3, 4, 5, 6, 7]

Second Step:
    => Now store the first 2 elements into the temp[] array.
    => temp[] = [3, 4, 5, 6, 7, 1, 2]

Third Steps:
    => Copy the elements of the temp[] array into the original array.
    => arr[] = temp[] So arr[] = [3, 4, 5, 6, 7, 1, 2]

Step-by-step approach:

• Initialize a temporary array(temp[n]) of length same as the original array
• Initialize an integer(k) to keep a track of the current index
• Store the elements from the position d to n-1 in the temporary array
• Now, store 0 to d-1 elements of the original array in the temporary array
• Lastly, copy back the temporary array to the original array

Below is the implementation of the above approach :

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {


// Function to rotate array
static void Rotate(int arr[], int d, int n)
{
    // Storing rotated version of array
    int temp[] = new int[n];

    // Keeping track of the current index
    // of temp[]
    int k = 0;

    // Storing the n - d elements of
    // array arr[] to the front of temp[]
    for (int i = d; i < n; i++) {
        temp[k] = arr[i];
        k++;
    }

    // Storing the first d elements of array arr[]
    // into temp
    for (int i = 0; i < d; i++) {
        temp[k] = arr[i];
        k++;
    }

    // Copying the elements of temp[] in arr[]
    // to get the final rotated array
    for (int i = 0; i < n; i++) {
        arr[i] = temp[i];
    }
}

// Function to print elements of array
static void PrintTheArray(int arr[], int n)
{
    for (int i = 0; i < n; i++) {
        System.out.print(arr[i]+" ");
    }
}
    public static void main (String[] args) {
        int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
        int N = arr.length;
        int d = 2;

        // Function calling
        Rotate(arr, d, N);
        PrintTheArray(arr, N);
    }
}

// This code is contributed by ishankhandelwals.

Output

3 4 5 6 7 1 2 

Time complexity: O(N) 
Auxiliary Space: O(N)

Java Program For Array Rotation by rotating one-by-one:

• At each iteration, shift the elements by one position to the left circularly (i.e., first element becomes the last).
• Perform this operation d times to rotate the elements to the left by d position.

Illustration:

Let us take arr[] = [1, 2, 3, 4, 5, 6, 7], d = 2.

First Step:
        => Rotate to left by one position.
        => arr[] = {2, 3, 4, 5, 6, 7, 1}

Second Step:
        => Rotate again to left by one position
        => arr[] = {3, 4, 5, 6, 7, 1, 2}

Rotation is done by 2 times.
So the array becomes arr[] = {3, 4, 5, 6, 7, 1, 2}

Step-by-step approach:

• Rotate the array to left by one position. For that do the following:
  • Store the first element of the array in a temporary variable.
  • Shift the rest of the elements in the original array by one place.
  • Update the last index of the array with the temporary variable.
• Repeat the above steps for the number of left rotations required.

Below is the implementation of the above approach:

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {

    public static void rotate(int arr[], int d, int n)
    {
        int p = 1;
        while (p <= d) {
            int last = arr[0];
            for (int i = 0; i < n - 1; i++) {
                arr[i] = arr[i + 1];
            }
            arr[n - 1] = last;
            p++;
        }

        for (int i = 0; i < n; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    public static void main(String[] args)
    {
        int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
        int N = arr.length;
        // Rotate 2 times
        int d = 2;

        // Function call
        rotate(arr, d, N);
    }
}
// contributed by keerthikarathan123

Output

3 4 5 6 7 1 2 

Time Complexity: O(N * d)
Auxiliary Space: O(1)

Java Program For Array Rotation using Juggling Algorithm:

Instead of moving one by one, divide the array into different sets where the number of sets is equal to the GCD of N and d (say X. So the elements which are X distance apart are part of a set) and rotate the elements within sets by 1 position to the left. 

• Calculate the GCD between the length and the distance to be moved.
• The elements are only shifted within the sets.
• We start with temp = arr[0] and keep moving arr[I+d] to arr[I] and finally store temp at the right place.

Step-by-step approach:

• Perform d%n in order to keep the value of d within the range of the array where d is the number of times the array is rotated and N is the size of the array.
• Calculate the GCD(N, d) to divide the array into sets.
• Run a for loop from 0 to the value obtained from GCD.
  • Store the value of arr[i] in a temporary variable (the value of i denotes the set number).
  • Run a while loop to update the values according to the set.
• After exiting the while loop assign the value of arr[j] as the value of the temporary variable (the value of j denotes the last element of the i^th set).

Below is the implementation of the above approach :

Java

// Java program to rotate an array by
// d elements
import java.io.*;
class RotateArray {
    /*Function to left rotate arr[] of size n by d*/
    void leftRotate(int arr[], int d, int n)
    {
        /* To handle if d >= n */
        d = d % n;
        int i, j, k, temp;
        int g_c_d = gcd(d, n);
        for (i = 0; i < g_c_d; i++) {
            /* move i-th values of blocks */
            temp = arr[i];
            j = i;
            while (true) {
                k = j + d;
                if (k >= n)
                    k = k - n;
                if (k == i)
                    break;
                arr[j] = arr[k];
                j = k;
            }
            arr[j] = temp;
        }
    }

    /*UTILITY FUNCTIONS*/

    /* function to print an array */
    void printArray(int arr[], int size)
    {
        int i;
        for (i = 0; i < size; i++)
            System.out.print(arr[i] + " ");
    }

    /*Function to get gcd of a and b*/
    int gcd(int a, int b)
    {
        if (b == 0)
            return a;
        else
            return gcd(b, a % b);
    }

    // Driver program to test above functions
    public static void main(String[] args)
    {
        RotateArray rotate = new RotateArray();
        int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
        rotate.leftRotate(arr, 2, 7);
        rotate.printArray(arr, 7);
    }
}

// This code has been contributed by Mayank Jaiswal

Output

3 4 5 6 7 1 2 

Time complexity : O(N) 
Auxiliary Space : O(1)

Please refer complete article on Program for array rotation for more details!