旋转数组 空间复杂度为O(1) 的2 种方法 + 1种空间复杂度O(n)

题目地址 ： 旋转数组.

网上好多不是根本就是错的，就是空间复杂度不是真正为1

下面总结一下

方法1

普通方法(空间复杂度不满足要求，但是题目并不会判错，说明他们没用对空间进行校验）
···
public void rotate1(int[] nums, int k) {
if(nums.length == 1 || k == 0) return;

    k = k % nums.length;
    int[] ans = new int[nums.length];
    for (int i = 0, j = k; i < nums.length; i++) {
        ans[j] = nums[i];
        j = (j+1) % nums.length;
    }
    System.out.println("Arrays.toString(ans) = " + Arrays.toString(ans));
    for(int i = 0; i < nums.length; i++){
        nums[i] = ans[i];
    }
}

···

方法2：

3次倒置，这个方法思路很巧妙，很经典。
先全部倒置，然后0到k-1倒置，然后k到最后再倒置，就得到了正确结果，空间复杂度1，（交换只耗费1个额外空间）

倒置当然要自己写，用java自带的肯定就超过1空间复杂度了

方法3

这是我自己想的方法，每次把当前的给正确的位置，然后在把正确位置上的那个再给下一个正确的位置，但是这个方法有个坑，就是不一定一次轮回就能搞定，如果k和length都是偶数就会超过一次轮回。
我也没研究出来到底是几次轮回，但是有一种简单的方法，就是每次调换一次，就cnt++，当cnt==length的时候就完成了。在这之前不断轮回，每次轮回，从当前的位置+1. 第一次轮回把nums[0]当成一个临时变量（每次轮回完了，num[0]自动会是正确的数字， 第二次轮回就是num[1]...）

public void rotate(int[] nums, int k) {
        if(nums.length == 1 || k == 0) return;
        k = k % nums.length;
        int cnt = 0, r = 0, j;
        while(cnt < nums.length){
            j = k + r;
            while (true) {
                System.out.println(nums[r] + "  " + nums[j]);
                int t = nums[j];
                nums[j] = nums[r];
                nums[r] = t;
                j = (j + k) % nums.length;
                cnt++;
                if(j == r){
                    cnt++;
                    break;
                }
            }
            System.out.println(Arrays.toString(nums));
            r++;
        }
//        System.out.println( Arrays.toString(nums));
    }