LeetCode刷题|189旋转数组

这题是LeetCode编辑的初级算法中的一题，先来看一下题目描述吧。

题目描述

LeetCode地址：旋转数组

这个题目可以说是相当熟悉了，题目意思也很好理解，当时考研的时候教材里面就有这个题目，但是隔了这么久再次看到时，竟然还是想不起来咋做。于是我又开始了我最擅长的暴力解题法。首先介绍一下我自己的菜鸡解法。

我的解法一

我看到这个题第一个想法就是再创建一个数组，然后把每个元素的index往后挪三位放到新建的数组中。数组下标加k后如果超过数组长度就减一个数组长度。因为题目要求原地解决，不能有返回值，因此最后再把得到的数组复制到原数组。（可以说是非常蠢了）

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        n = len(nums)
        if n<2:
            return
        new_nums = n*[0]
        i = 0
        for num in nums:
            if i+k<n:
                new_nums[i+k] = num
                i = i+1
            else:
                t = k
                while(i+t>=n):
                    t = t-n
                new_nums[i+t] = num
                i = i+1
        j = 0
        for new_num in new_nums:
            nums[j] = new_num
            j = j+1

但是上面说的思路还有一个问题，那就是k的值可能比数组长度还要大。因此就算减去一个数组长度n还是会越界，所以else部分加了一个循环，让下标和k的和循环减n，直到比数组长度要小就结束。这样就解决了所有问题。但是这个while循环做了很多无用功，白白耗费了很多时间，所以这个地方还是不太合理。

我的解法二

我所谓的解法二其实跟解法一差不多。解法一是将整个数组复制了一遍，这里我考虑只复制前面n-k个元素，将后面k个元素挪到前面k个位置，然后再将前面的n-k个元素往右挪k个单位。本质上跟上一种方法一样，直接看一下代码吧：

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        n = len(nums)
        if n<2:
            return
        while(k>=n):
            k = k - n
        new_nums = (n-k)*[0]
        for i in range(0,n-k):
            new_nums[i] = nums[i]
        a = 0
        for j in range(n-k,n):
            nums[a] = nums[j]
            a = a+1
        for new_num in new_nums:
            nums[a] = new_num
            a = a+1

看了官方解法之后发现，我那个用while循环操作真的是太蠢了，直接一个取余操作秒杀我😭

class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length;
        int[] newArr = new int[n];
        for (int i = 0; i < n; ++i) {
            newArr[(i + k) % n] = nums[i];
        }
        System.arraycopy(newArr, 0, nums, 0, n);
    }
}

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

看完官方这简洁的代码再看一下自己的，简直就是一坨屎。。。

我的解法三

这种解法就是教材上面的解法了，很多同学应该都比较熟悉。数组往右移动k位，先把数组整个做一个翻转，然后再把前k位翻转，最后再把后面n-k位翻转就得到最终的结果。

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        n = len(nums)
        while(n<k):
            k = k-n
        self.reverse(nums,0,n)
        self.reverse(nums,0,k)
        self.reverse(nums,k,n)
        
    def reverse(self, num: List[int], m: int, n: int):
        for i in range(m,(n+m)//2):
            t = num[i]
            num[i] = num[m+n-i-1]
            num[m+n-i-1] = t

可以看到，这个方法虽然实现了在原地操作数组，但是好像性能还是不太行。（可能是我代码写的不太行，思路应该没问题吧
最后还有一种官方比较复杂的解法，俺也没咋看懂，希望看懂的小伙伴可以给我解释一下😅

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;
    }
}

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