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

   filter_none

   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

   filter_none

   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

   filter_none

   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

   filter_none

   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

   filter_none

   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

   filter_none

   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.