LeetCode 189. 旋转数组（中等）

189. 旋转数组

给定一个数组，将数组中的元素向右移动 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) 的 原地 算法。

我的java代码：

方法一：暴力解法

思路：先想到的是最直接的想法，循环k次，每次数组向右移动一位，循环结束后解决问题。这是最直接的方法，时间复杂度o(n*k)，效率低。

class Solution {
    public void rotate(int[] nums, int k) {
        int len = nums.length;
		for(int i = 0;i < k;i++) {
			int t = nums[len-1];
			for(int j = len-2;j >= 0;j--) {
				nums[j+1] = nums[j];
			}
			nums[0] = t;
		}
    }
}

方法二：先交换 len-k 个元素

思路：先将前 len-k 个元素与后 len-k 个元素交换，即先将前 len-k 个元素向前移动 k 个位置，使它们处于最终位置，再去处理移动后的其他元素。这里考虑了k可能大于数组长度所以取余，考虑k为0时就不用移动直接返回。虽然时间复杂度最差也会达到o(n*k)，但相较第一种方法效率提高了一点。

class Solution {
    public void rotate(int[] nums, int k) {
       int len = nums.length;
		k = k % len;
		if(k == 0) {
			return;
		}
		for(int i = len-k-1;i >= 0;i--) {
			int t = nums[i];
			nums[i] = nums[i+k];
			nums[i+k] = t;
		}
		for(int i = 0;i < len-k;i++) {
			int t = nums[0];
			for(int j = 1;j < k;j++) {
				nums[j-1] = nums[j];
			}
			nums[k-1] = t;
		}
    }
}

学习别人的代码：

方法一：数组翻转

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

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

nums = "----->-->"; k =3
result = "-->----->";

reverse "----->-->" we can get "<--<-----"
reverse "<--" we can get "--><-----"
reverse "<-----" we can get "-->----->"

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

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

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

方法二：环状替换

思路：

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

       我们从位置 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,kn,k 的公倍数。又因为我们在第一次回到起点时就结束，因此 a 要尽可能小，故 an 就是 n,kn,k 的最小公倍数 lcm(n,k)，因此 b 就为 lcm(n,k) / k。

       这说明单次遍历会访问到 lcm(n,k) / k 个元素。为了访问到所有的元素，我们需要进行遍历的次数为：

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

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

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

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）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。