Leetcode小白试炼（20200918 旋转数组）

一、题目

1. 题目描述

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。要求使用空间复杂度为O(1)。

2. 示例

示例 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]

3. 题目分析

本题目的是让数组整体发生移动，并且要求空间复杂度为$O(1)$。题目一目了然，很好理解。

二、解法

1. 个人解法

（1）代码

public class Arrayxuanzhuan_1 {
    public void rotate(int[] nums, int k) {

        while (k != 0) {
            int temp = nums[nums.length - 1];
            for (int i = nums.length - 1; i > 0; i--) {
                nums[i] = nums[i - 1];
            }
            nums[0] = temp;
            k--;
        }
    }

    public static void main(String[] args) {
        Arrayxuanzhuan_1 xz = new Arrayxuanzhuan_1();
        int[] nums = {-1,-100,3,99};
        xz.rotate(nums, 2);
        for (int num : nums) {
            System.out.println(num);
        }
    }
}

（2）解法分析

本来想一次循环直接搞定，但是没构思好如何跳过已经在正确位置上的元素以及终止条件。之后看到示例的解释，想到了这种方法：
整体思路：
每次数组整体向右移动一位，直至达到要求要移动的位置。
每次的整体移动分析：
先暂存nums[num.length-1]，之后让数组中其余元素从后到前依次向右移动一位，移动完毕后将暂存的元素放到nums[0]，此时即完成了一次整体移动。

（3）解法缺点分析

• 这种方法移动次数随着k的增长而增长，不是最优解法。
• 没有考虑k过大的时候怎么办，这里应该对k进行一个处理：

 k = k % nums.length;

时间复杂度：$O(k\ast n)$

（4）提交截图

2. 官网高星解法

（1）环状替代

其实刚开始自己想到的就是环状替代法的思想，但是没有考虑好终止条件，以及没有想到整个序列的替换顺序。看到高星解法里的分析是真的牛！

解法分析

使用环状替代法，有两种情况：

• 情况一：n和k的最大公约数等于1

如左图，我们一次遍历就可以完成替换。
情况一终止条件：
如果将目前操作的元素再进行一次替代回到了原位，那此时就不能进行这次替代，退出即完成。

• 情况二：n和k的最大公约数是$m(m\ne 1)$

如右图，我们需要m次遍历可以完成替换。
情况二终止条件：
我们每次遍历的其实都是数组的不同分组，即每一轮遍历只会在自己的那一分组上进行。每一轮遍历的终止条件同情况一。
m次遍历都结束，即整体完成。

note： 两种情况其实有一种通用的结束条件，即统计交换次数。我们数组中的n个元素，每次替换都会有一个元素归位，因此我们可以定义一个count来统计替换次数，当$count=n$的时候，完成退出。

代码

 public void rotate(int[] nums, int k) {
        int len = nums.length;
        k = k % len;//对k进行处理
        int count = 0;         // 记录交换位置的次数，n个同学一共需要换n次
        for (int start = 0; count < len; start++) {//start是这次循环分组的起始元素
            int cur = start;       // 从0位置开始换位子（记录要换位置的人的坐标）
            int pre = nums[cur];//pre放的是将要换位置的元素
            do {
                int next = (cur + k) % len;//找自己应该去的地方
                int temp = nums[next];    // 这个地方原有的人来到角落...
                nums[next] = pre;//搬入自己应该去的地方
                pre = temp;//此时角落那个人变为要换位置的元素，将这个元素用循环外的变量记录，方便下次循环的进行
                cur = next;//用循环外的变量记录下角落那个人的坐标，方便下次循环的进行
                count++;//完成一次换位置，计数+1
            } while (start != cur);     // 循环暂停，回到起始位置，角落无人

        }
    }

算法分析

虽然有可能对多个分组进行循环遍历，但是整体长度是n，故：
时间复杂度：$O(n)$
空间复杂度：$O(1)$

提交截图

不知道为啥这个执行时间是0ms。。

（2）反转数组

解法分析

解决字符串或者数组旋转问题，常用反转数组法。这个方法基于一个事实：若我们需要将数组中的元素向右移动 k 个位置， 那么 k%l (l为数组长度) 的尾部元素会被移动到头部，剩下的元素会被向后移动。
反转步骤：
我们需要进行三次反转
1.整体反转
2.对前k个元素，数组下标范围[0,n-k-1]进行反转
3.对剩余元素，数组下标范围[n-k,n-1]进行反转
特殊情况分析：

• 反转函数中需要用k来截取需要反转的子数组，故我们要考虑利用取余操作来处理k大于数组长度的特殊情况。
• 输入的k可能为0或者为数组长度的整数倍，这个时候不需要进行反转。
• 当数组长度为1的时候，不需要进行反转。

代码

   /**
     * 反转函数
     *
     * @param nums  要反转数组
     * @param start 开始下标
     * @param end   结束下标
     */
    void invert(int nums[], int start, int end) {
        for (int i = 0; i < (end - start + 1) / 2; i++) {
            int temp = nums[start + i];
            nums[start + i] = nums[end - i];
            nums[end - i] = temp;
        }
    }

    /**
     * 反转数组法
     *
     * @param nums
     * @param k
     */
    public void rotate_2(int[] nums, int k) {
        k = k % nums.length;//防止出现因k大于数组长度而出现的数组越界错误
        if (k > 0 && nums.length > 1) {//k=0或数组长度为1的时候不需要反转
            invert(nums, 0, nums.length - 1);
            invert(nums, 0, k - 1);
            invert(nums, k, nums.length - 1);
        }
    }

    public static void main(String[] args) {
        Arrayxuanzhuan_1 xz = new Arrayxuanzhuan_1();
        int[] nums = {1, 2, 3, 4, 5, 6, 7};
        xz.rotate_2(nums, 3);
        for (int num : nums) {
            System.out.println(num);
        }
    }

算法分析

虽然进行了三次反转，但是三次反转中总共进行的元素交换次数不超过n次，遍历整个数组一共两次，故：
时间复杂度：$O(n)$
空间复杂度：$O(1)$

提交截图

未考虑k大于数组长度的提交截图：

考虑到k有可能会大于数组长度以及数组只有一个元素的情况的提交截图：