有
n
个整数，使其前面各数顺序向后移
m
个位置，最后
m
个数变成最前面的
m
个数

1. public static void main(String[] args) {
   
2.                 int shift = 3;
   
3.                 int[] arr;
   
4. 
   
5.                 arr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
   
6.                 shiftLeft(arr, shift);
   
7.                 System.out.printf("向左移动%d %s%n", shift, Arrays.toString(arr));
   
8. 
   
9.                 arr = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
   
10.                 shiftRight(arr, shift);
    
11.                 System.out.printf("向右移动%d %s%n", shift, Arrays.toString(arr));
    
12.         }
    
13. 
    
14.         /**
    
15.          * 向右移动 要求 arr != null && arr.length >= 1 && shift >= 0
    
16.          */
    
17.         public static void shiftRight(int[] arr, int shift) {
    
18.                 if ((shift %= arr.length) == 0) {
    
19.                         return;
    
20.                 }
    
21. 
    
22.                 int len = arr.length;
    
23.                 int step = GCD(len, shift);
    
24.                 int round = len / step;
    
25. 
    
26.                 for (int i = 0; i < step; i++) {
    
27.                         int t = arr[(i + shift * round) % len], index1 = 0, index2 = 0;
    
28.                         for (int j = round; j > 1; j--) {
    
29.                                 index2 = (i + shift * j - shift) % len;
    
30.                                 index1 = (index2 + shift) % len;
    
31. 
    
32.                                 arr[index1] = arr[index2];
    
33.                         }
    
34.                         arr[index2] = t;
    
35.                 }
    
36.         }
    
37. 
    
38.         /**
    
39.          * 向左移动 要求 arr != null && arr.length >= 1 && shift >= 0
    
40.          */
    
41.         public static void shiftLeft(int[] arr, int shift) {
    
42.                 if ((shift %= arr.length) == 0) {
    
43.                         return;
    
44.                 }
    
45. 
    
46.                 int len = arr.length;
    
47.                 int step = GCD(len, shift);
    
48.                 int round = len / step;
    
49. 
    
50.                 for (int i = 0; i < step; i++) {
    
51.                         int t = arr[i], index1 = 0, index2 = 0;
    
52.                         for (int j = 0; j < round - 1; j++) {
    
53.                                 index1 = (i + shift * j) % len;
    
54.                                 index2 = (index1 + shift) % len;
    
55. 
    
56.                                 arr[index1] = arr[index2];
    
57.                         }
    
58.                         arr[index2] = t;
    
59.                 }
    
60.         }
    
61. 
    
62.         /**
    
63.          * 辗转相除法求最大公约数 要求 a > 0 && b > 0
    
64.          */
    
65.         public static int GCD(int a, int b) {
    
66.                 while (b != 0) {
    
67.                         int t = a;
    
68.                         a = b;
    
69.                         b = t % b;
    
70.                 }
    
71.                 return a;
    
72.         }

复制代码

如果您觉得我的回答还满意的话，请回复一下我
我的QQ：2355928351
如果您还有其他的入学前问题可以加我的QQ