算法题 轮转数组

LeetCode 189. 轮转数组

问题描述

给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置（k 是非负数）。

示例：

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

方法一：使用额外数组（空间复杂度 O(n)）

思路

1. 计算实际轮转步数：k % nums.length（避免无效旋转）
2. 创建新数组：将原数组元素按轮转后位置放入新数组
3. 复制回原数组：用 System.arraycopy 高效复制

代码实现

class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length;
        k = k % n; // 实际有效轮转步数
        if (k == 0) return; // 无需旋转
        
        int[] temp = new int[n];
        // 将原数组元素放入新数组的正确位置
        for (int i = 0; i < n; i++) {
            temp[(i + k) % n] = nums[i];
        }
        // 将新数组复制回原数组
        System.arraycopy(temp, 0, nums, 0, n);
    }
}

算法分析

• 时间复杂度：O(n)
  遍历数组两次（写新数组 + 复制回原数组）
• 空间复杂度：O(n)
  需要额外数组存储结果

---

方法二：环状替换（空间复杂度 O(1)）

思路

1. 环形移动：将元素直接放到最终位置
2. 处理闭环：使用最大公约数确定循环次数
3. 保存临时值：在替换过程中保存被覆盖的值

代码实现

class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length;
        k = k % n; // 实际有效轮转步数
        if (k == 0) return;
        
        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); // 回到起点时结束循环
        }
    }
    
    // 计算最大公约数（欧几里得算法）
    private int gcd(int a, int b) {
        return b == 0 ? a : gcd(b, a % b);
    }
}

算法分析

• 时间复杂度：O(n)
  每个元素仅移动一次
• 空间复杂度：O(1)
  仅使用常数级额外空间

---

方法三：三次翻转（空间复杂度 O(1)）

思路

1. 整体翻转：反转整个数组
2. 局部翻转：翻转前 k 个元素
3. 局部翻转：翻转剩余元素

代码实现

class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length;
        k = k % n; // 实际有效轮转步数
        if (k == 0) return;
        
        reverse(nums, 0, n - 1); // 翻转整个数组
        reverse(nums, 0, k - 1); // 翻转前k个元素
        reverse(nums, k, n - 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(n)
• 空间复杂度：O(1)
  仅使用常数级额外空间

---

对比

方法	时间复杂度	空间复杂度	特点
额外数组	O(n)	O(n)	简单直观
环状替换	O(n)	O(1)	空间最优，逻辑复杂
三次翻转	O(n)	O(1)	最优解（推荐）

---

测试用例

public static void main(String[] args) {
    Solution sol = new Solution();
    // 测试用例1：常规情况
    int[] nums1 = {1,2,3,4,5,6,7};
    sol.rotate(nums1, 3);
    System.out.println(Arrays.toString(nums1)); // [5,6,7,1,2,3,4]
    
    // 测试用例2：k大于数组长度
    int[] nums2 = {-1,-100,3,99};
    sol.rotate(nums2, 6); // 实际旋转2步
    System.out.println(Arrays.toString(nums2)); // [3,99,-1,-100]
    
    // 测试用例3：k=0
    int[] nums3 = {1,2,3};
    sol.rotate(nums3, 0);
    System.out.println(Arrays.toString(nums3)); // [1,2,3]
    
    // 测试用例4：空数组
    int[] nums4 = {};
    sol.rotate(nums4, 3);
    System.out.println(Arrays.toString(nums4)); // []
    
    // 测试用例5：单元素数组
    int[] nums5 = {1};
    sol.rotate(nums5, 100);
    System.out.println(Arrays.toString(nums5)); // [1]
}

---

关键点

1. 取模操作：k = k % nums.length 避免无效旋转
2. 环状替换核心：
   • 使用最大公约数确定循环次数
   • 闭环条件 start != current
3. 三次翻转核心：
   • 整体翻转：reverse(0, n-1)
   • 前部翻转：reverse(0, k-1)
   • 后部翻转：reverse(k, n-1)
4. 边界处理：
   • 空数组和单元素数组直接返回
   • k=0 时无需操作