1. 首页
  2. LeetCode

每日一道 LeetCode (42):旋转数组

每日一道 LeetCode (42):旋转数组

每天 3 分钟,走上算法的逆袭之路。

前文合集

每日一道 LeetCode 前文合集

代码仓库

GitHub: https://github.com/meteor1993/LeetCode

Gitee: https://gitee.com/inwsy/LeetCode

题目:旋转数组

题目来源:https://leetcode-cn.com/problems/rotate-array/

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

示例 1:

输入: [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:

输入: [-1,-100,3,99] 和 k = 2
输出: [3,99,-1,-100]
解释: 
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]

说明:

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

解题方案一:暴力法

暴力解题大家应该都想得到,就是用两个循环套起来,然后加一个中间变量来逐位替换位置。

public void rotate(int[] nums, int k) {
    int temp, previous;
    for (int i = 0; i < k; i++) {
        previous = nums[nums.length - 1];
        for (int j = 0; j < nums.length; j++) {
            temp = nums[j];
            nums[j] = previous;
            previous = temp;
        }
    }
}

每日一道 LeetCode (42):旋转数组

运行时长又超过 3 位数了,智商不行的人可能就单纯的比较适合看答案。

解题方案二:使用额外的数组

这竟然都算一个解题方案,题目上不是说要求使用空间复杂度为 O(1) 的 原地 算法么?

还带这么玩的啊!

好吧好吧,你是答案,你说了算,你说啥都对。

能用额外数组这个题就很简单了,直接新建一个数组,然后把每个元素直接放在正确的位置上,最后放完以后再用这个数组对原数组挨个赋值。

public void rotate_1(int[] nums, int k) {
    int[] a = new int[nums.length];
    for (int i = 0; i < nums.length; i++) {
        a[(i + k) % nums.length] = nums[i];
    }
    for (int i = 0; i < nums.length; i++) {
        nums[i] = a[i];
    }
}

每日一道 LeetCode (42):旋转数组

时间下降到 1ms ,有这么立竿见影的么,不过只超过了 57.17% 的人,说明还有更快的方案,接着往下看答案。

解题方案三:使用环状替换

这个方案有点意思,确实很难想,我就借用下官方的图做下解释:

每日一道 LeetCode (42):旋转数组

这个图是是画了一个数组的移动过程:

nums: [1, 2, 3, 4, 5, 6]
k: 2
  • 第一次移动,从第一个 1 开始, 1 向后移动两位,到了 3 现在的位置,这时我们需要将 1 放到位置 3 上。
  • 第二次移动,因为 3 没有了位置,我们接着计算 3 要移动的位置,发现 3 要移动到位置 5 上,那么我们把 3 移动过去。
  • 第三次移动,现在是 5 没有了位置,计算 5 需要的位置,在位置 1 上,而位置 1 现在正好空着,我们把 5 放进去。
  • 第四次移动,开始画红线的部分,现在我们该移动位置 2 上的数字 2 了, 2 需要移动到位置 4 上,我们把 2 移动过去。
  • ……

剩下的两次移动我就不写了,和绿线部分是一致的。

当整体移动完成后,整个数组我们实际上只循环了一次,就完成了所有的移动,这个时间复杂度是 O(n) 。

下面的代码上注释我已经都写好了,就不再解释了:

public void rotate_2(int[] nums, int k) {
    // 先计算 k ,这个 k 为当前需要移动的位置,防止 k 超出数组长度
    k = k % nums.length;
    // 初始化移动的次数
    int count = 0;
    for (int start = 0; count < nums.length; start++) {
        // 初始化当前位置
        int current = start;
        // 初始化要移动的数
        int prev = nums[start];
        do {
            // 计算目标要移动的位置
            int next = (current + k) % nums.length;
            // 定义中间变量
            int tmp = nums[next];
            // 将要移动的数字进行赋值
            nums[next] = prev;
            // 这时,接着移动刚才被挤掉位置的数
            prev = tmp;
            // 变化当前的位置为刚才移动的位置
            current = next;
            // 将操作次数 +1
            count++;
        } while (start != current);
    }
}

每日一道 LeetCode (42):旋转数组

果然只遍历一次耗时足够低,不过时间复杂度为 O(n) 的还有下面的另一种思路。

解题方案四:使用反转

这个操作也是相当的骚,我是真的服。

答案上是这么解释这个方案的:

这个方法基于这个事实:当我们旋转数组 k 次, k % n 个尾部元素会被移动到头部,剩下的元素会被向后移动。

这句话看完我一脸懵,这是说了个啥?然后接着往下看。

在这个方法中,我们首先将所有元素反转。然后反转前 k 个元素,再反转后面 n - k 个元素,就能得到想要的结果。

这句话是看懂了,但是没明白意思,直到看到了题目上举的例子才看懂:

假设 n=7 且 k=3 。

原始数组                  : 1 2 3 4 5 6 7
反转所有数字后             : 7 6 5 4 3 2 1
反转前 k 个数字后          : 5 6 7 4 3 2 1
反转后 n-k 个数字后        : 5 6 7 1 2 3 4 --> 结果

妈耶,这还是人能想出来的方案么?这题套路这么深还能算是一道简单题么?

方案有了实际上代码就很简单了:

public void rotate_3(int[] nums, int k) {
    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--;
    }
}

每日一道 LeetCode (42):旋转数组

这后面的简单题是越来越难了,严重感觉自己现在智商不够用,看来是时候买点猪头肉补补了。

转载声明:本博客由极客挖掘机创作,采用 CC BY 3.0 CN 许可协议。可自由转载、引用,但需署名作者且注明文章出处。如转载至微信公众号,请在文末添加作者公众号二维码。

发表评论

电子邮件地址不会被公开。 必填项已用*标注

QR code