给定大小为N和D索引的数组arr [] ，任务是将数组旋转D索引。
向左旋转：数组从左向右旋转D元素
例子：
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
- 使用临时数组
方法：在此方法中，只需创建一个临时数组并将数组arr []的元素从0复制到Dth索引。移动之后，将数组arr []的其余元素从索引D移至N。然后将临时数组元素移至原始数组。
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]下面是上述方法的实现：
// 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); } }输出：3 4 5 1 2时间复杂度： O(N)
辅助空间： O(D) -
一张一张地旋转：
方法：逐一递归旋转数组-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要旋转一个，将arr [0]存储在一个临时变量temp中，将arr [1]移至arr [0]，将arr [2]移至arr [1]…最后将temp移至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.下面是上述方法的实现：
// 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); } }输出：3 4 5 1 2时间复杂度： O(N * D)
辅助空间： O(1) - 杂耍算法：
方法：这是方法2的扩展。而不是一个一个地移动数组，而是将数组划分为不同的集合，其中集合的数量等于n和d的GCD并在集合内移动元素。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.
下面是上述方法的实现：
// 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); } }输出：3 4 5 1 2时间复杂度： O(n)
辅助空间： O(1)
向右旋转：数组从右向右旋转D元素
例子：
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
- 使用临时数组
方法：在此方法中，只需创建一个临时数组并将数组arr []的元素从0复制到N – D索引。移动之后，将数组arr []的其余元素从索引D移至N。然后将临时数组元素移至原始数组。
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]下面是上述方法的实现：
// 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); } }输出：4 5 1 2 3时间复杂度： O(N)
辅助空间： O(D) -
一张一张地旋转：
方法：逐一递归旋转数组-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要旋转一个，将arr [N]存储在临时变量temp中，将arr [N-1]移至arr [N]，将arr [N-2]移至arr [N-1]…最后将temp移至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.下面是上述方法的实现：
// 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); } }输出：4 5 1 2 3时间复杂度： O(N * D)
辅助空间： O(1) - 杂耍算法：
方法：这是方法2的扩展。而不是一个一个地移动数组，而是将数组划分为不同的集合，其中集合的数量等于n和d的GCD并在集合内移动元素。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.
下面是上述方法的实现：
// 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); } }输出：4 5 1 2 3时间复杂度： O(n)
辅助空间： O(1)