轮转数组[中等]

优质博文：IT-BLOG-CN

一、题目

给定一个整数数组nums，将数组中的元素向右轮转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 <= 105
-231 <= nums[i] <= 231 - 1
0 <= k <= 105

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

二、代码

【1】使用额外的数组： 我们可以使用额外的数组来将每个元素放至正确的位置。我们遍历原数组，将原数组下标为i的元素放至新数组下标为(i+k) mod nums.length的位置，最后将新数组拷贝至原数组即可。

class Solution {
    public void rotate(int[] nums, int k) {
        // 使用一个等长的数组
        int[] newArray = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            newArray[(i + k) % nums.length] = nums[i];
        }
        System.arraycopy(newArray, 0, nums, 0, nums.length);
    }
}

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

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

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

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

操作	结果
原始数组	1 2 3 4 5 6 7
翻转所有元素	7 6 5 4 3 2 1
翻转[0,k mod n−1]区间的元素	5 6 7 4 3 2 1
翻转 [k mod n,n−1]区间的元素	5 6 7 1 2 3 4

class Solution {
    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);
    }

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

【3】环状替换： 方法一中使用额外数组的原因在于如果我们直接将每个数字放至它最后的位置，这样被放置位置的元素会被覆盖从而丢失。因此，从另一个角度，我们可以将被替换的元素保存在变量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个元素。为了访问到所有的元素，我们需要进行遍历的次数为n/(lcm(n,k)/k)=nk/(lcm(n,k))=gcd(n,k)

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

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

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

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

class Solution {
    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;
    }
}

时间复杂度： O(n)其中n为数组的长度。每个元素只会被遍历一次。
空间复杂度： O(1)我们只需常数空间存放若干变量。