算法 LC 旋转数组

题目描述

给你一个数组，将数组中的元素向右轮转 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

每向右轮转1个位置，都删除数组末尾元素，再在开头插入原末尾元素
数组中的元素向右轮转n（数组长度n）个位置，轮转后的数组中所有元素的位置都未发生变化。
因而数组向右轮转k个位置，等价于向右轮转k%n个位置
for循环k%n次，每次都将数组最后一次元素temp移除，并在数组开头插入末尾元素temp

+ (void)rotate1:(NSMutableArray *)nums k:(int)k {
    int n = (int)nums.count;
    for (int i=0; i

    static public func rotate1(_ nums: inout [Int], _ k:Int) {
        let n:Int = nums.count
        let k = k%n
        
        for _ in 0..

解题思路2 - 使用额外的数组

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

+ (void)rotate2:(NSMutableArray *)nums k:(int)k {
    int n = (int)nums.count;
    NSMutableArray *newNums = [NSMutableArray arrayWithArray:nums];
    for (int i=0; i

    static public func rotate2(_ nums: inout [Int], _ k:Int) {
        let n:Int = nums.count
        let k = k%n

        var newNums = [Int](repeating: 0, count: n)
        for i in 0..

解题思路3 - 环状替换

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

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

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

由于最终回到了起点，故该过程恰好走了整数量的圈，不妨设为a圈，再设该过程总共遍历了b个元素，在这个过程中每遍历一个元素都是向右移动了k个元素，因而我们有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)

+ (void)rotate3:(NSMutableArray *)nums k:(int)k {
    int n = (int)nums.count;
    k = k%n;
    int count = [self mygcd:n b:k];
    
    for (int i=0; i0) {
        r = b;
        b = a%b;
        a = r;
    }
    return b;
}

    static public func rotate3(_ nums: inout [Int], _ k: Int) {
        if k == 0 {return}
        if nums.count < 2 {return}
        let n:Int = nums.count
        let k = k%n
        
        let count = mygcd(n, k)
        for i in 0.. Int {
        if b == 0 {return a}
        var a = a
        var b = b
        // 辗转相除法 获取最大公约数
        while (a%b) != 0 {
            let temp = b
            b = a%b
            a = temp
        }
        return b
    }

解题思路3 - 数组翻转

该方法基于如下的事实：当我们将数组的元素向右移动k次后，尾部k%n个元素会移动至数组头部，其余元素向后移动k%n个位置。
该方法为数组的翻转：我们可以先将所有元素翻转，这样尾部的k%n个元素就被移至数组头部，然后我们再翻转[0,k%n - 1]区间的元素和
[k%n,n-1]区间的元素即能得到最后的答案

我们以n=7，k=3 为例进行如下展示：
原始数组 1，2，3，4，5，6，7
翻转所有元素 7，6，5，4，3，2，1
翻转[0,k%n - 1]区间的元素 5，6，7，4，3，2，1
翻转[k%n,n-1]区间的元素 5，6，7，1，2，3，4

+ (void)rotate4:(NSMutableArray *)nums k:(int)k {
    int n = (int)nums.count;
    k = k%n;
    
    // 翻转所有元素
    [self myreverse:nums start:0 end:n-1];
    
    // 翻转[0,k%n - 1]区间的元素
    [self myreverse:nums start:0 end:k-1];
    
    // 翻转[k%n,n-1]区间的元素
    [self myreverse:nums start:k end:n-1];
    
}

+ (void)myreverse:(NSMutableArray *)nums start:(int)start end:(int)end {
    while (start

    static public func rotate4(_ nums: inout [Int], _ k: Int) {
        let n:Int = nums.count
        let k = k%n
        
        myreverse(&nums, 0, n-1)
        myreverse(&nums, 0, k-1)
        myreverse(&nums, k, n-1)

    }
    
    static func myreverse(_ nums: inout [Int], _ start:Int, _ end:Int) {
        var start = start
        var end = end
        while start < end {
            let prev = nums[start]
            nums[start] = nums[end]
            nums[end] = prev
            start += 1
            end -= 1
        }
    }

参考：https://leetcode-cn.com/leetbook/read/top-interview-questions-easy/x2skh7/