Leetcode 189.旋转数组

题目：
给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

进阶：
尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？

示例1：

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]

示例2：

输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释: 
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]

这是一道看了就会有思路的题，你可能会想到很多方法来解决这个问题，但是想要设计一个空间复杂度为O(1)的原地算法还是有一定难度的。下面由易到难介绍三种方法。

方法一：辅助数组

使用辅助数组，即另外开辟一个新的数组来将元素放到正确的位置。用n表示数组的长度，从左到右依次遍历原数组，将原数组中下标为 i 的元素放到新数组下标为 (i+k)%n 的位置，最后将新数组拷贝至原数组即可。

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> array(n);
        for (int i = 0; i < n; i++) {
            array[(i + k) % n] = nums[i];
        }
        //assign()为拷贝函数
        nums.assign(array.begin(), array.end());  //array.end()指向最后一个元素的下一个位置
    }
};

方法二：翻转数组

方法一使用额外的数组存储，会导致空间复杂度为O(n)。为了寻找更优的解决思路，我们采用一种常量级的空间复杂度解法：翻转数组。
第一步，翻转整个数组。
第二步，从第 (k mod n) 个元素后，将整个数组分割为左右两部分。
第三步，分别翻转左右两个数组，完成。
可以说是一种非常巧妙的解法，空间复杂度为O(1)。

这里翻转数组的时候可以使用C++自带的reverse函数，当然也可以自己写一个翻转函数，反正不难，怎么样都可以啦。

class Solution {
public:
    void reverse(vector<int>& nums, int start, int end) {
        while (start < end) {
            swap(nums[start], nums[end]);
            start++;
            end--;
        }
    }
    void rotate(vector<int>& nums, int k) {
        k = k % nums.size();
        reverse(nums, 0, nums.size() - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k , nums.size() - 1);
    }
};

方法三：环形替换

从 nums[0] 开始，每次移动 k 个位置，将 nums[0] 移动到 nums[k%n] ，nums[k] 移动到 nums[2k%n] ，以此类推，直到所有元素全部归位。这种方法不需要额外的数组空间，只需要使用几个变量临时存储即将被替换的数组元素。

下面看几个例子：

n = 5，k = 2，一次循环即可将所有元素归位。

n = 6，k = 2

一次循环，只替换了一半的元素，即只有一半的元素归位，此时，需要进行二次循环，从元素nums[1]开始，

n = 6，k = 3，这种情况就必须执行三次循环才能完成所有元素的替换

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int count = 0, j, temp, pre;
        int n = nums.size();
        for (int i = 0; i < k; i++) {
            pre = nums[i];
            j = i;
            while ((j + k) % n != i) {
                temp = nums[(j + k) % n];
                nums[(j + k) % n] = pre;
                j = (j + k) % n;
                pre = temp;
                count++;
            }
            nums[i] = pre;
            count++;
            if (count == n)   break;
        }
    }
};