旋转数组的几种解法

例：给定一个数组，将数组中的元素向右或向左移动k次
int[] A={1,2,3,4,5,6,7} 向右移动k=3次，结果为{5，6，7，1，2，3，4}
解法1： 直接旋转法

public static void rotate1(int[] nums, int k) {
    for (int i = 0; i < k; i++) {
        int prev = nums[nums.length - 1];
        for (int j = 0; j < nums.length; j++) {
            int temp = nums[j];
            nums[j] = prev;
            prev = temp;
        }
    }
    System.out.println(Arrays.toString(nums));
}

将数组的最后一个数字保存起来。在内层循环中j++，一直与prev交换，保证实现一次完整的旋转，需要k次，外层循环k次。
在内存循环里，每个元素都被移动一次（O（n）），外层循环k次（O（K）），时间复杂度O（n * k）。

解法2： 使用额外的数组

public static void rotate2(int[] nums, int k){
    int[] nums1 = new int[nums.length];
    for(int i = 0;i < nums.length;i++){
        nums1[(i + k) % nums.length] = nums[i];
    }
    for(int i = 0; i < nums1.length;i++){
        nums[i] = nums1[i];
    }
    System.out.println(Arrays.toString(nums));
}

重新创建一个新的数组，将旋转k次之后的正确的位置的正确是值写入新数组中。nusm1[(i + k) % nums.length] = nums[i].
时间复杂度：O（n）
空间复杂度：O（n）

解法3： 使用反转，反转数组

public static void rotate3(int[] nums, int k){
        k = k % nums.length;
        reverse(nums,0,nums.length - 1);
        reverse(nums,0,k -1);
        reverse(nums,k,nums.length - 1);
        System.out.println(Arrays.toString(nums));
    }
    public static void reverse(int[] nums,int A,int B){
//        if(A < B) {
//            for (int i = A; i < B / 2 ; i++) {
//                int fron = nums[i];
//                nums[i] = nums[B - i];
//                nums[B - i] = fron;
//            }
//        }
//错误原因：当k = 3时，循环相当于没跑
        while(A < B){
            int fron = nums[A];
            nums[A] = nums[B];
            nums[B] = fron;
            A++;
            B--;
        }
    }

反转数组过程：
原始数组：{1，2，3，4，5，6，7}
第一步：先将数组整个反转回来即：{7，6，5，4，3，2，1}；
第二部：将前K个先反转回来，即{5，6，7，4，3，2，1}；
第三步：将后 n- k个数字反转回来，即{5，6，7，1，2，3，4}.

时间复杂度：O（1）
空间复杂度：O（1）
注意：在反转数组reverse这个方法中，不能使用for循环，用while循环，注意必须条件 A < B 的使用。