How to Left or Right rotate an Array in Java

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

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 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)

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

Output:

3 4 5 1 2

Time complexity: O(N * D)
Auxiliary Space: O(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[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 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); 
    } 
} 

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

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

Output:

4 5 1 2 3

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

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 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)

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

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

Left Rotate: Array rotate by D element from left

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Right Rotate:Array rotate by D element from Right

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Recommended Posts: