初级算法-旋转数组

解题思路：

1. 拿到题，首先想到的解题思路是以nums.length - k为界限，将屁股那截放到新的数组的头部，把剩下的头部那截放到新的数组的屁股，最后将新的数组给回到nums就可以了。
   代码如下：

	public static void rotate(int[] nums, int k) {
        int len = nums.length;
        if (k > len) {
            k = k % len;
        }
        int[] result = new int[len];
        System.arraycopy(nums, len - k, result, 0, k);
        System.arraycopy(nums, 0, result, k, len - k);
        System.arraycopy(result, 0, nums, 0, len);
    }

2. 官方的解法在复制值那里有一个很巧妙的思路，就是(i + k) % nums.length，这样当i + k 小于nums.length的时候，将会把原数组后移k个位置，而当i + k 大于nums.length 的时候，取到的余数正好是剩下的k， 就很自然的赋值到了头部那k个之前空的位置上。
   代码如下：

    public void rotate(int[] nums, int k) {
        int n = nums.length;
        int[] newArr = new int[n];
        for (int i = 0; i < n; ++i) {
            newArr[(i + k) % n] = nums[i];
        }
        System.arraycopy(newArr, 0, nums, 0, n);
    }

现在开始考虑空间复杂度为O(1)的解法。

3. 借用插入排序的思想，从后面依次取出来元素，放到temp里，然后找到待放的位置，把数组后移空出这个位置，然后把temp赋值进这个位置，性能并不好，只是一个思路罢了。
   代码如下：

    public static void rotate(int[] nums, int k) {
        if (k > nums.length) {
            k = k % nums.length;
        }
        for (int i = 0; i < k; i++) {
            int temp = nums[nums.length - k + i];
            System.arraycopy(nums, i, nums, 1 + i, nums.length - k);
            nums[i] = temp;
        }
    }

4. 官网的环状替换逻辑不是很好理解，大致意思是循环将元素直接后移k个位置，直到索引和初始位置重合，但是重合的时候，可能不是所有元素都移动了，所以我们要直到这个循环需要多少轮，所有的元素才能到对应位置，这里我贴一下官网推导：
   
   最终得到结论我们需要多少轮循环是数组长度和k的最大公约数。
   代码如下：

	public void rotate(int[] nums, int k) {
        int n = nums.length;
        k = k % n;
        int count = gcd(k, n);
        for (int start = 0; start < count; ++start) {
            int current = start;
            int prev = nums[start];
            do {
                int next = (current + k) % n;
                int temp = nums[next];
                nums[next] = prev;
                prev = temp;
                current = next;
            } while (start != current);
        }
    }

    public int gcd(int x, int y) {
        return y > 0 ? gcd(y, x % y) : x;
    }

5. 官网还有一种很巧妙的解法，就是数组翻转，首先我们对整个数组进行翻转，然后将翻转后的数组的前k个元素再翻转一下，再把后面剩余的元素进行翻转，这样，首先前k个元素就是最初元素的后k个元素的逆序经翻转后，产生预期结果，后nums.length-k个元素就是最初那些需要后移k的元素。
   代码如下：

    public void rotate(int[] nums, int k) {
        k %= nums.length;
        reverse(nums, 0, nums.length - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.length - 1);
    }

    public void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int temp = nums[start];
            nums[start] = nums[end];
            nums[end] = temp;
            start += 1;
            end -= 1;
        }
    }