【每日力扣3】旋转数组

一、题目

给你一个数组，将数组中的元素向右轮转 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 <= 10^5
• -2^31 <= nums[i] <= 2^31 - 1
• 0 <= k <= 10^5

进阶：

尽可能想出更多的解决方案，至少有 三种 不同的方法可以解决这个问题。

你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？

二、思路

（1）看见涉及到数组内元素位置移动，最直接想法便是开辟一块新的数组空间，通过这个新数组和原数组两个数组之间的互相拷贝完成位置的移动。

点开“执行代码”，第一个测试用例通过了！ 

信心满满点“提交”，结果失败了！

噢！！原来还有k≥数组长度的情况！！于是乎在前面加上两行

 while(n <= k)

            k-=n;

这里也给了以后写代码的启示：每次要考虑到特殊的退化情况

以下是完整的代码

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n = nums.size();
        while(n <= k)
            k-=n;
        int* New_nums = new int[n];
        for(int i = 0; i < n-k;i++)
            New_nums[i + k] = nums[i];
        for(int i = n-k; i < n; i++)
            New_nums[i -(n - k)] = nums[i];
        for(int i = 0; i< n; i++)
            nums[i] = New_nums[i];
        delete []New_nums;
    }
};

 空间消耗有点多，在空间方面有待改进！

（2）如果不开辟新的数组，就在原数组原地操作呢？

于是引入一个变量temp，用于存交换的中间值，每一次就把nums最末尾的数移到开头，如此循环k次。

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n = nums.size();
        int temp;
        while(k--)
        {
            temp = nums[n-1];
            for(int i = n-1;i>0;i--)
                nums[i] = nums[i-1];
            nums[0] = temp;
        }
    }
};

这样空间消耗问题解决了，为O（1），但是时间嘛……毕竟时间复杂度为O（N²）提交代码后，果然

三、官方解法

方法一：使用额外的数组

我们可以使用额外的数组来将每个元素放至正确的位置。用 n 表示数组的长度，我们遍历原数组，将原数组下标为 i 的元素放至新数组下标为 (i+k) mod n 的位置，最后将新数组拷贝至原数组即可。

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> newArr(n);
        for (int i = 0; i < n; ++i) {
            newArr[(i + k) % n] = nums[i];
        }
        nums.assign(newArr.begin(), newArr.end());
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/rotate-array/solution/xuan-zhuan-shu-zu-by-leetcode-solution-nipk/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

• 时间复杂度： O(n)，其中 n 为数组的长度。

• 空间复杂度： O(n)。

方法二：环状替换
方法一中使用额外数组的原因在于如果我们直接将每个数字放至它最后的位置，这样被放置位置的元素会被覆盖从而丢失。因此，从另一个角度，我们可以将被替换的元素保存在变量 temp 中，从而避免了额外数组的开销。

我们从位置 0 开始，最初令 temp=nums[0]。根据规则，位置 0 的元素会放至 (0+k) mod n 的位置，令 x = (0+k) mod n，此时交换 temp 和 nums[x]，完成位置 x 的更新。然后，我们考察位置 x，并交换 temp 和 nums[(x+k) mod n]，从而完成下一个位置的更新。不断进行上述过程，直至回到初始位置 0。

容易发现，当回到初始位置 0 时，有些数字可能还没有遍历到，此时我们应该从下一个数字开始重复的过程，可是这个时候怎么才算遍历结束呢？我们不妨先考虑这样一个问题：从 0 开始不断遍历，最终回到起点 0 的过程中，我们遍历了多少个元素？

由于最终回到了起点，故该过程恰好走了整数数量的圈，不妨设为 a 圈；再设该过程总共遍历了 b 个元素。因此，我们有 an=bk，即 an 一定为 n,k 的公倍数。又因为我们在第一次回到起点时就结束，因此 a 要尽可能小，故 an 就是 n,k 的最小公倍数 lcm(n,k)，因此 b 就为 lcm(n,k)/k。

这说明单次遍历会访问到 lcm(n,k)/k 个元素。为了访问到所有的元素，我们需要进行遍历的次数为

其中 gcd 指的是最大公约数。

我们用下面的例子更具体地说明这个过程：

nums = [1,2,3,4,5,6]

k = 2

如果读者对上面的数学推导的理解有一定困难，也可以使用另外一种方式完成代码：使用单独的变量 count 跟踪当前已经访问的元素数量，当 count=n 时，结束遍历过程。

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n = nums.size();
        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;
                swap(nums[next], prev);
                current = next;
            } while (start != current);
        }
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/rotate-array/solution/xuan-zhuan-shu-zu-by-leetcode-solution-nipk/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

• 时间复杂度：O(n)，其中 n 为数组的长度。每个元素只会被遍历一次。

• 空间复杂度：O(1)。我们只需常数空间存放若干变量。

方法三：数组翻转
该方法基于如下的事实：当我们将数组的元素向右移动 k 次后，尾部 kmodn 个元素会移动至数组头部，其余元素向后移动 kmodn 个位置。

该方法为数组的翻转：我们可以先将所有元素翻转，这样尾部的 kmodn 个元素就被移至数组头部，然后我们再翻转 [0,kmodn−1] 区间的元素和 [kmodn,n−1] 区间的元素即能得到最后的答案。

我们以 n=7，k=3 为例进行如下展示：

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

    void rotate(vector<int>& nums, int k) {
        k %= nums.size();
        reverse(nums, 0, nums.size() - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.size() - 1);
    }
};

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/rotate-array/solution/xuan-zhuan-shu-zu-by-leetcode-solution-nipk/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

 复杂度分析

• 时间复杂度：O(n)，其中 n 为数组的长度。每个元素被翻转两次，一共 n 个元素，因此总时间复杂度为 O(2n)=O(n)。
• 空间复杂度：O(1)。

四、学习心得

1.写算法时要考虑到特殊的或者是习惯思维意外的情况，用if语句写在一般情况的前面。如本题的"k大于数组长度"的情况，则需将 k %= n。

2.表达式(i + k) mod n的妙处：①将区间段nums[0,n-k)与nums[n-k,n)放在了一起，不需要分开讨论 ②考虑到了k≥n的情况，避免了额外讨论！

3.数组的环状替换法，如果不想使用额外空间（声明新的数组空间），那可以在原数组上进行环状替换来操作。