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) 的 原地 算法解决这个问题吗？

package com.leetcode.mianshi;

import java.util.Arrays;
import java.util.stream.IntStream;

/**
 * LeetCode 189：轮转数组 —— 公平性能对比测试
 * 
 * 改进目标：
 * 1. 每个方法独立使用原始数组的拷贝，保证初始状态一致。
 * 2. 预热 + 多次测试取平均，减少 JVM 优化和 GC 干扰。
 * 3. 测试三种不同 k 值（小、中、大），观察不同场景下的性能表现。
 * 4. 数组规模适中（1000 万），避免 OOM，同时耗时差异足够明显。
 * 
 * @author z (优化版)
 */
public class Leetcode_189_Solution {

    // ---------- 测试配置参数 ----------
    private static final int ARRAY_SIZE = 10_000_000;          // 数组长度：1000 万（约 40 MB）
    private static final int WARMUP_ITERATIONS = 3;            // 预热次数
    private static final int TEST_ITERATIONS = 5;              // 正式测试次数（取平均）
    private static final int[] K_VALUES = {3, ARRAY_SIZE / 2, ARRAY_SIZE - 3}; // 小、中、大三种 k

    // ---------- 主测试入口 ----------
    public static void main(String[] args) {
        // 生成原始升序数组（所有方法都基于它的拷贝进行操作）
        int[] original = getInt(ARRAY_SIZE);
        System.out.println("数组大小: " + ARRAY_SIZE);
        System.out.println("预热次数: " + WARMUP_ITERATIONS + "，正式测试次数: " + TEST_ITERATIONS);

        // 对每种 k 值分别测试所有方法
        for (int k : K_VALUES) {
            System.out.println("\n========== k = " + k + " ==========");
            // 依次测试 6 种方法，每种方法都独立拷贝原始数组
            testMethod("方法1 (手工临时数组, 循环拷贝)", original, k, Lecode_189_Solution::rotate1);
            testMethod("方法2 (System.arraycopy临时数组)", original, k, Lecode_189_Solution::rotate2);
            testMethod("方法3 (Stream拼接)", original, k, Lecode_189_Solution::rotate3);
            testMethod("方法4 (三次反转, 空间O(1))", original, k, Lecode_189_Solution::rotate4);
            testMethod("方法5 (取模新数组 + arraycopy回拷)", original, k, Lecode_189_Solution::rotate5);
            testMethod("方法6 (取模新数组 + for循环回拷)", original, k, Lecode_189_Solution::rotate6);
        }
    }

    /**
     * 通用测试方法：对指定的轮转函数进行预热和正式测试，输出平均耗时（毫秒）。
     * 
     * @param name     方法名称（显示用）
     * @param original 原始数组（不会被修改，每次测试都会拷贝）
     * @param k        轮转位数
     * @param func     待测试的轮转函数（函数式接口）
     */
    private static void testMethod(String name, int[] original, int k, RotateFunction func) {
        // ----- 预热阶段 -----
        // 目的：让 JVM 将热点代码编译为机器码，避免 JIT 影响正式测试
        for (int i = 0; i < WARMUP_ITERATIONS; i++) {
            int[] copy = Arrays.copyOf(original, original.length); // 每次拷贝独立数组
            func.rotate(copy, k);                                  // 执行轮转
        }

        // ----- 正式测试阶段 -----
        long totalNanos = 0;
        for (int i = 0; i < TEST_ITERATIONS; i++) {
            int[] copy = Arrays.copyOf(original, original.length); // 重新拷贝，保证初始状态一致
            long start = System.nanoTime();                        // 高精度计时（纳秒）
            func.rotate(copy, k);
            long end = System.nanoTime();
            totalNanos += (end - start);
        }
        // 计算平均耗时，并转换为毫秒（保留两位小数）
        double avgMs = totalNanos / (TEST_ITERATIONS * 1_000_000.0);
        System.out.printf("%s 平均耗时: %.2f ms\n", name, avgMs);
    }

    /**
     * 函数式接口，用于传递轮转方法。
     */
    @FunctionalInterface
    interface RotateFunction {
        void rotate(int[] nums, int k);
    }

    // ---------- 工具方法：生成测试数组 ----------
    /**
     * 构造升序测试数组：元素为 1 ~ length。
     * 
     * @param length 数组长度
     * @return 升序数组（若 length <= 0 返回空数组）
     */
    public static int[] getInt(int length) {
        if (length <= 0) {
            return new int[0];
        }
        int[] nums = new int[length];
        for (int i = 0; i < length; i++) {
            nums[i] = i + 1;
        }
        return nums;
    }

    // ---------- 6 种轮转实现（严格保持原始逻辑） ----------

    /**
     * 方法1：手工临时数组（纯 while 循环）
     * 思路：保存末尾 k 个元素到临时数组，将前部元素后移，再将临时数组放回头部。
     * 时间复杂度 O(n)，空间复杂度 O(k)
     */
    public static void rotate1(int[] nums, int k) {
        int n = nums.length;
        int turnRight = k % n;          // 有效轮转步数
        if (turnRight == 0) {
            return;
        }

        int[] temp = new int[turnRight];
        // 1. 保存末尾 turnRight 个元素到 temp（逆序保存，但回填时按顺序）
        int a = turnRight - 1;
        int b = n - 1;
        while (a >= 0) {
            temp[a--] = nums[b--];
        }
        // 2. 将剩余元素整体后移 turnRight 位
        while (b >= 0) {
            nums[b + turnRight] = nums[b--];
        }
        // 3. 将 temp 回填到数组头部（temp 中元素顺序正确）
        int c = turnRight - 1;
        while (c >= 0) {
            nums[c] = temp[c--];
        }
    }

    /**
     * 方法2：System.arraycopy 临时数组
     * 思路：与方法1相同，但使用 System.arraycopy 进行批量拷贝，性能更高。
     * 时间复杂度 O(n)，空间复杂度 O(k)
     */
    public static void rotate2(int[] nums, int k) {
        int n = nums.length;
        int turnRight = k % n;
        if (turnRight == 0) {
            return;
        }
        int[] temp = new int[turnRight];
        // 1. 末尾 turnRight 个元素 -> temp
        System.arraycopy(nums, n - turnRight, temp, 0, turnRight);
        // 2. 开头元素整体后移 turnRight 位
        System.arraycopy(nums, 0, nums, turnRight, n - turnRight);
        // 3. temp 回填到头部
        System.arraycopy(temp, 0, nums, 0, turnRight);
    }

    /**
     * 方法3：Stream 拼接
     * 思路：用 IntStream 将“末尾段 + 开头段”拼接成新数组，再拷回原数组。
     * 时间复杂度 O(n)，空间复杂度 O(n)（新数组 + Stream 内部开销）
     */
    public static void rotate3(int[] nums, int k) {
        int n = nums.length;
        int turnRight = k % n;
        if (turnRight == 0) {
            return;
        }
        // 拼接：先取末尾 turnRight 个，再取开头剩余部分
        int[] nums2 = IntStream.concat(
                Arrays.stream(nums, n - turnRight, n),
                Arrays.stream(nums, 0, n - turnRight)
        ).toArray();
        // 将结果拷回原数组
        System.arraycopy(nums2, 0, nums, 0, n);
    }

    /**
     * 方法4：三次反转（原地操作，空间最优）
     * 思路：整体反转 → 反转前 turnRight 段 → 反转后 n-turnRight 段。
     * 时间复杂度 O(n)，空间复杂度 O(1)
     */
    public static void rotate4(int[] nums, int k) {
        int n = nums.length;
        int turnRight = k % n;
        if (turnRight == 0) {
            return;
        }
        // 1. 整体反转
        reverse(nums, 0, n - 1);
        // 2. 反转前 turnRight 个元素
        reverse(nums, 0, turnRight - 1);
        // 3. 反转剩余部分
        reverse(nums, turnRight, n - 1);
    }

    /**
     * 辅助方法：反转数组指定区间 [start, end]（闭区间）
     */
    private static void reverse(int[] nums, int start, int end) {
        while (start < end) {
            int tmp = nums[start];
            nums[start++] = nums[end];
            nums[end--] = tmp;
        }
    }

    /**
     * 方法5：取模定位（新数组）+ System.arraycopy 回拷
     * 思路：元素 i 轮转后应落在 (i+k)%n 位置，先写入临时数组，再批量拷回。
     * 时间复杂度 O(n)，空间复杂度 O(n)
     */
    public static void rotate5(int[] nums, int k) {
        int n = nums.length;
        int turnRight = k % n;
        if (turnRight == 0) {
            return;
        }
        int[] temp = new int[n];
        // 计算每个元素的目标位置
        for (int i = 0; i < n; i++) {
            temp[(i + k) % n] = nums[i];
        }
        // 使用 System.arraycopy 批量回拷
        System.arraycopy(temp, 0, nums, 0, n);
    }

    /**
     * 方法6：取模定位（新数组）+ for 循环回拷
     * 思路：与方法5相同，但回拷改用 for 循环逐元素赋值，对比两种回拷方式的性能差异。
     * 时间复杂度 O(n)，空间复杂度 O(n)
     */
    public static void rotate6(int[] nums, int k) {
        int n = nums.length;
        int turnRight = k % n;
        if (turnRight == 0) {
            return;
        }
        int[] temp = new int[n];
        // 计算每个元素的目标位置
        for (int i = 0; i < n; i++) {
            temp[(i + k) % n] = nums[i];
        }
        // 使用 for 循环逐个回拷
        for (int i = 0; i < n; i++) {
            nums[i] = temp[i];
        }
    }
}

方法1到方法6是网上查的，自己写的1，2，总结下来，AI辅助是一方面，把理解是很重要的。AI有很多种解决方案，但是适合自己的才是好的。