C++算法成长之路：旋转数组 （ez)

难度：EZ

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

示例 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]

提示：

1 <= nums.length <= 2 * 10^4
-2^31 <= nums[i] <= 2^31-1
0 <= k<= 10^5

我的解决方法：使用临时数组

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int numlength = nums.size();
        int copynum[numlength];
		
        for(int i =0; i < numlength;i++){
            copynum[i] = nums[i];
        }

        for(int i = 0; i < numlength; i++){
            nums[(i+k)%numlength] = copynum[i];
        }
    }
};

最终运行结果：

离谱。运行时间0ms我是第一次见到…ovo

思考：
可以使用的其他方法：

1.多次反转

先反转全部数组，在反转前k个，最后在反转剩余的，如下所示

    public void rotate(int[] nums, int k) {
        int length = nums.length;
        k %= length;
        reverse(nums, 0, length - 1);//先反转全部的元素
        reverse(nums, 0, k - 1);//在反转前k个元素
        reverse(nums, k, length - 1);//接着反转剩余的
    }

    //把数组中从[start，end]之间的元素两两交换,也就是反转
    public void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int temp = nums[start];
            nums[start++] = nums[end];
            nums[end--] = temp;
        }
    }

其实还可以在调整下，先反转前面的，接着反转后面的k个，最后在反转全部，原理都一样

    public void rotate(int[] nums, int k) {
        int length = nums.length;
        k %= length;
        reverse(nums, 0, length - k - 1);//先反转前面的
        reverse(nums, length - k, length - 1);//接着反转后面k个
        reverse(nums, 0, length - 1);//最后在反转全部的元素
    }

    //把数组中从[start，end]之间的元素两两交换,也就是反转
    public void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int temp = nums[start];
            nums[start++] = nums[end];
            nums[end--] = temp;
        }
    }

2.环形旋转
类似约瑟夫环一样，把数组看作是环形的，每一个都往后移动k位，这个很好理解



但这里有一个坑，如果

nums.length%k=0

也就是数组长度为k的倍数，这个会原地打转，如下图所示

对于这个问题我们可以使用一个数组visited表示这个元素有没有被访问过，如果被访问过就从他的下一个开始，防止原地打转。

    public static void rotate(int[] nums, int k) {
        int hold = nums[0];
        int index = 0;
        int length = nums.length;
        boolean[] visited = new boolean[length];
        for (int i = 0; i < length; i++) {
            index = (index + k) % length;
            if (visited[index]) {
                //如果访问过，再次访问的话，会出现原地打转的现象，
                //不能再访问当前元素了，我们直接从他的下一个元素开始
                index = (index + 1) % length;
                hold = nums[index];
                i--;
            } else {
                //把当前值保存在下一个位置，保存之前要把下一个位置的
                //值给记录下来
                visited[index] = true;
                int temp = nums[index];
                nums[index] = hold;
                hold = temp;
            }
        }
    }

部分引用代码来源：数据结构和算法