Skip to content
Related Articles

Related Articles

How to Left or Right rotate an Array in Java
  • Difficulty Level : Medium
  • Last Updated : 30 Jul, 2020

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 intial 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 :

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    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 :

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    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 :

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    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 intial 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 :

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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)
        {
            // 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);
        }
    }

    chevron_right

    
    

    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 :

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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);
        }
    }

    chevron_right

    
    

    Output:

    4 5 1 2 3
    

    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[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 :

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

    // 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 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);
        }
    }

    chevron_right

    
    

    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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :