Skip to content
Related Articles

Related Articles

Improve Article
How to Left or Right rotate an Array in Java
  • Difficulty Level : Medium
  • Last Updated : 08 Jun, 2021

Given an array arr[] of size N and D index, the task is to rotate the array by the D index.
 

Left Rotate: Array rotate by D element from left

Example:
 

Input: 
arr[] = {1, 2, 3, 4, 5} 
D = 2 
Output: 
3 4 5 1 2 
Explanation: The initial array [1, 2, 3, 4, 5] 
rotate by first index [2, 3, 4, 5, 1] 
rotate by second index [3, 4, 5, 1, 2]
Input: 
arr[] = {10, 34, 56, 23, 78, 12, 13, 65} 
D = 7 
Output: 
65 10 34 56 23 78 12 13 

1. Using temp array
Approach: In this method simply create a temporary array and copy the elements of the array arr[] from 0 to the Dth index. After that move, the rest elements of the array arr[] from index D to N. Then move the temporary array elements to the original array.
 

Input arr[] = [1, 2, 3, 4, 5], D = 2 
1) Store the first d elements in a temp array: temp[] = [1, 2] 
2) Shift rest of the arr[]: arr[] = [3, 4, 5] 
3) Store back the D elements: arr[] = [3, 4, 5, 1, 2] 
 



Below is the implementation of the above approach :

Java




// Java program to left rotate
// an array by D elements
 
class GFG {
 
    // Function to left rotate arr[]
    // of size N by D
    void leftRotate(int arr[], int d, int n)
    {
        // create temp array of size d
        int temp[] = new int[d];
 
        // copy first d element in array temp
        for (int i = 0; i < d; i++)
            temp[i] = arr[i];
 
        // move the rest element to index
        // zero to N-d
        for (int i = d; i < n; i++) {
            arr[i - d] = arr[i];
        }
 
        // copy the temp array element
        // in origninal array
        for (int i = 0; i < d; i++) {
            arr[i + n - d] = temp[i];
        }
    }
 
    // utility function to print an array
    void printArray(int arr[], int n)
    {
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }
 
    // Driver program to test above functions
    public static void main(String[] args)
    {
        GFG rotate = new GFG();
        int arr[] = { 1, 2, 3, 4, 5 };
        rotate.leftRotate(arr, 2, arr.length);
        rotate.printArray(arr, arr.length);
    }
}
Output: 
3 4 5 1 2

 

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

2. Rotate one by one: 
Approach: Rotate the array recursively one by one element- 
 

Input arr[] = [1, 2, 3, 4, 5], D = 2
1) swap arr[0] to arr[1] 
2) swap arr[1] to arr[2] 



3) swap arr[N-1] to arr[N] 
4) Repeat 1, 2, 3 to D times 
 

To rotate by one, store arr[0] in a temporary variable temp, move arr[1] to arr[0], arr[2] to arr[1] …and finally temp to arr[n-1]
 

Let us take the same example arr[] = [1, 2, 3, 4, 5], d = 2 
Rotate arr[] by one 2 times 
We get [2, 3, 4, 5, 1] after first rotation and [ 3, 4, 5, 1, 2] after second rotation.

Below is the implementation of the above approach : 
 

Java




// Java program to left rotate
// an array by d elements
 
class GFG {
 
    // Function to left rotate arr[]
    // of size n by d
    void leftRotate(int arr[],
                    int d, int n)
    {
        for (int i = 0; i < d; i++)
            leftRotatebyOne(arr, n);
    }
 
    void leftRotatebyOne(int arr[], int n)
    {
        int i, temp;
        temp = arr[0];
        for (i = 0; i < n - 1; i++)
            arr[i] = arr[i + 1];
        arr[i] = temp;
    }
 
    // utility function to print an array
    void printArray(int arr[], int n)
    {
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }
 
    // Driver program to test above functions
    public static void main(String[] args)
    {
        GFG rotate = new GFG();
        int arr[] = { 1, 2, 3, 4, 5 };
        rotate.leftRotate(arr, 2, arr.length);
        rotate.printArray(arr, arr.length);
    }
}
  1.  
Output: 



3 4 5 1 2

 

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

3. A Juggling Algorithm: 
Approach: This is an extension of method 2. Instead of moving one by one, divide the array into different sets where the number of sets is equal to GCD of n and d and move the elements within sets.
 

If GCD is 1 as-is for the above example array (n = 5 and d = 2), then elements will be moved within one set only, we just start with temp = arr[0] and keep moving arr[I+d] to arr[I] and finally store temp at the right place.

Below is the implementation of the above approach :
 

Java




// Java program to left rotate
// an array by d elements
 
class GFG {
 
    // Function to left rotate arr[]
    // of siz 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;
        }
    }
 
    // 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)
    {
        GFG rotate = new GFG();
        int arr[] = { 1, 2, 3, 4, 5 };
        rotate.leftRotate(arr, 2, arr.length);
        rotate.printArray(arr, arr.length);
    }
}
  1.  
Output: 
3 4 5 1 2

 

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

Right Rotate: Array rotate by D element from Right

Example:

Input: 
arr[] = {1, 2, 3, 4, 5} 
D = 2 
Output: 
4 5 1 2 3 
Explanation: 
The initial array [1, 2, 3, 4, 5] 
rotate first index [2, 3, 4, 5, 1] 
rotate second index [3, 4, 5, 1, 2] 
rotate third index [4, 5, 1, 2, 3]
Input: 
arr[] = {10, 34, 56, 23, 78, 12, 13, 65} 
D = 5 
Output: 
56 23 78 12 13 65 10 34 
 

1. Using temp array
Approach: In this method simply create a temporary array and copy the elements of the array arr[] from 0 to the N – D index. After that move, the rest elements of the array arr[] from index D to N. Then move the temporary array elements to the original array.
 

Input arr[] = [1, 2, 3, 4, 5], D = 2
1) Store the first d elements in a temp array
   temp[] = [1, 2, 3]
2) Shift rest of the arr[]
   arr[] = [4, 5]
3) Store back the D elements
   arr[] = [4, 5, 1, 2, 3]

Below is the implementation of the above approach :
 



Java




// Java program to rotate an array by
// D elements
 
class GFG {
    // Function to right rotate arr[]
    // of size N by D
 
    void rightRotate(int arr[], int d, int n)
    {
          // if arr is rotated n times then
          // you get the same array
          while(d > n){
            d = d - n;
        }
       
        // create temp array of size d
        int temp[] = new int[n - d];
 
        // copy first N-D element in array temp
        for (int i = 0; i < n - d; i++)
            temp[i] = arr[i];
 
        // move the rest element to index
        // zero to D
        for (int i = n - d; i < n; i++) {
            arr[i - d - 1] = arr[i];
        }
 
        // copy the temp array element
        // in origninal array
        for (int i = 0; i < n - d; i++) {
            arr[i + d] = temp[i];
        }
    }
 
    // utility function to print an array
    void printArray(int arr[], int n)
    {
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }
 
    // Driver program to test above functions
    public static void main(String[] args)
    {
        GFG rotate = new GFG();
        int arr[] = { 1, 2, 3, 4, 5 };
        rotate.rightRotate(arr, 2, arr.length);
        rotate.printArray(arr, arr.length);
    }
}
  1.  
Output: 
4 5 1 2 3

 

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

2. Rotate one by one: 
Approach: Rotate the array recursively one by one element- 
 

Input arr[] = [1, 2, 3, 4, 5], D = 2
1) swap arr[N] to arr[N-1] 
2) swap arr[N-1] to arr[N-2] 



3) swap arr[2] to arr[1] 
4) Repeat 1, 2, 3 to D times 
 

To rotate by one, store arr[N] in a temporary variable temp, move arr[N-1] to arr[N], arr[N-2] to arr[N-1] … and finally temp to arr[1]
 

Let us take the same example arr[] = [1, 2, 3, 4, 5], d = 2 
Rotate arr[] by one 2 times 
We get [5, 1, 2, 3, 4] after first rotation and [ 4, 5, 1, 2, 3] after second rotation.

Below is the implementation of the above approach : 
 

Java




// Java program to rotate an array by
// d elements
 
class GFG {
 
    // Function to right rotate arr[]
    // of size n by d
    void rightRotate(int arr[],
                     int d, int n)
    {
        for (int i = n; i > d; i--)
            rightRotatebyOne(arr, n);
    }
 
    void rightRotatebyOne(int arr[], int n)
    {
        int i, temp;
        temp = arr[0];
        for (i = 0; i < n - 1; i++)
            arr[i] = arr[i + 1];
        arr[i] = temp;
    }
 
    // utility function to print an array
    void printArray(int arr[], int n)
    {
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }
 
    // Driver program to test above functions
    public static void main(String[] args)
    {
        GFG rotate = new GFG();
        int arr[] = { 1, 2, 3, 4, 5 };
        rotate.rightRotate(arr, 2, arr.length);
        rotate.printArray(arr, arr.length);
    }
}
Output: 
4 5 1 2 3

 

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

1. A Juggling Algorithm: 
Approach: This is an extension of method 2. Instead of moving one by one, divide the array into different sets where the number of sets is equal to GCD of n and d and move the elements within sets.

If GCD is 1 as-is for the above example array (n = 5 and d =2), then elements will be moved within one set only, we just start with temp = arr[N] and keep moving arr[I+d] to arr[I] and finally store temp at the right place.

Below is the implementation of the above approach :
 

Java




// Java program to rotate an array by
// d elements
 
class GFG {
 
    // Function to right rotate arr[]
    // of siz N by D
    void rightRotate(int arr[], int d, int n)
    {
 
        // to neglect n rotations if rtotations is greater
        // than size of arr
        while (d > n) {
            d = d - n;
        }
        // to use as left rotation
        d = n - d;
        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)
    {
        GFG rotate = new GFG();
        int arr[] = { 1, 2, 3, 4, 5 };
        rotate.rightRotate(arr, 2, arr.length);
        rotate.printArray(arr, arr.length);
    }
}
Output
4 5 1 2 3 

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes 

My Personal Notes arrow_drop_up
Recommended Articles
Page :