leetcode--189. 轮转数组

给定一个整数数组 nums，将数组中的元素向右轮转 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 <= nums.length <= 105
-231 <= nums[i] <= 231 - 1
0 <= k <= 105

进阶：
尽可能想出更多的解决方案，至少有 三种 不同的方法可以解决这个问题。
你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？

题解

方法1：使用额外数组

思路：创建一个新的数组来存放轮转后的元素。对于原数组中的每个元素，计算它在新数组中的位置，并将其复制到新位置上。这种方法的关键在于计算新位置时使用模运算(i + k) % n来确保索引不会超出数组的界限。

实现：

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

这种方法的时间复杂度为O(n)，空间复杂度为O(n)，因为需要一个与原数组同样大小的额外数组来存放结果。

方法2：使用反转

思路：这种方法不需要使用额外的空间。首先将整个数组反转，这样末尾的k个元素就被移动到了数组的前面。然后，分别反转数组的前k个元素和剩下的元素，以恢复这些元素的原始顺序。

实现：

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

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

这种方法的时间复杂度为O(n)，空间复杂度为O(1)。通过三次反转操作，实现了数组的轮转而不需要额外的存储空间。

方法3：环状替换

思路：通过计算每个元素的最终位置，并将其放到正确的位置上，同时保持空间复杂度为O(1)。这个方法避免了使用额外的数组空间，通过一次遍历完成所有元素的移动。

实现：

public void rotate(int[] nums, int 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 temp = nums[next];
            nums[next] = prev;
            prev = temp;
            current = next;
            count++;
        } while (start != current);
    }
}

这种方法的时间复杂度为O(n)，空间复杂度为O(1)。它通过环状替换的方式，一次遍历就完成了所有元素的正确移动，无需额外空间。

总结

这三种方法各有优缺点，使用额外数组的方法最直观简单，但空间复杂度较高；使用反转的方法空间复杂度最优，实现也相对简单；环状替换方法同样保持了O(1)的空间复杂度，但实现相对复杂。选择哪种方法取决于对时间复杂度和空间复杂度的具体要求。