AngstEssenSeeleLeetCode 189 这道题，我刷第一遍的时候差点直接跳过。轮转数组，不就是把数组往右挪几位吗？有什么好讲的。但后来拿它去带新人、自己也作为面试官用它出题，才发现这道题是把数组下标、取模、逆序反转、空间复杂度串联起来的绝佳训练题。它难度标签只是 Medium，但能把这题讲清楚的人，基本能在数组类问题上绕开大多数坑。
题目本身一句话就能概括：给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。比如 [1,2,3,4,5,6,7] 向右轮转 3 位，结果是 [5,6,7,1,2,3,4]。很多人一看到这个，第一反应就是“直接再申请一个数组，按下标映射放过去”，这确实是最容易想到的方案。但这题的难点和趣味全藏在另一个地方：如果题目要求只能用 O(1) 额外空间，你还能不能做？
1. 把题意翻译成人话：轮转的本质是一个平移问题
1.1 先分清“右移”和“左移”的公式
面试里遇到过不少候选人，上来就说这题简单，然后就把方向写反了。所以第一个要确认的事，就是“向右轮转”这四个字到底在说哪个方向。
从数组下标来看，向右轮转 k 位的意思是：原来在下标 i 的元素，移动后应该落在下标 (i + k) % n。以 [1,2,3,4,5,6,7]、k=3 为例，下标 0 上的数字 1 最终应该到下标 3，下标 4 上的数字 5 最终到下标 (4+3)%7=0，所以新数组开头是 5。
反过来，如果是“向左轮转 k 位”，目标下标就是 (i - k + n) % n。这里为什么要先加一个 n 再取模？因为很多编程语言对负数取模的结果并不统一。比如 Java 和 C++ 里 -1 % 7 的结果是 -1，而不是 6。如果直接写 (i - k) % n，下标一旦变负，程序就访问到错误位置了。有人觉得这是小事，但这类边界问题恰恰是线上 bug 最常见的来源。
1.2 两段视角：元素视角和区间视角
轮转操作可以从两个角度看：
- 元素视角：每个元素独立向右移动 k 步，越界的绕回数组头部。
- 区间视角：把数组从某个位置切成两段，交换两段的前后位置。
元素视角对应的是“额外数组”和“环状替换”的解法，区间视角对应的是“三次反转”解法。初学者通常只能看到元素视角，于是会写出暴力循环或申请新数组的代码。而真正高效的解法，往往需要跳出单个元素的层面，从整体结构上观察：右移 k 位，本质上就是让数组从“前 n-k 个元素 + 后 k 个元素”变成“后 k 个元素 + 前 n-k 个元素”。
换句话说，原数组可以看作 AB，其中 A 的长度是 n-k，B 的长度是 k。向右轮转 k 位的结果就是 BA。这个抽象非常关键，后面讲三次反转时会反复用到。
1.3 k 的范围决定了代码的第一道坎
题目说 k 是非负整数，但没说 k 一定小于数组长度。LeetCode 的测试用例里就有 nums = [1,2]、k = 3 这种情况，实际等价于轮转 3 % 2 = 1 次。所以无论用哪种解法，第一行几乎都逃不掉：
java复制k %= n;
如果不做取模，三次反转时 reverse(nums, 0, k-1) 里的 k-1 很可能直接越界；环状替换里虽然每次都会 % n，但链路会变得冗余，逻辑更难讲清楚。这条规则属于“先做归一化，再处理核心逻辑”的典型工程思维，在数组轮转、循环队列、分页计算里都能用上。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 先拿能过的方案打底：额外数组与朴素移位的界限
2.1 朴素移位为什么在面试中不建议写
很多人看到这道题，第一反应是：每次把最后一个元素摘出来，整体往后挪一位，再放到开头，重复 k 次。写成代码大概是这样：
java复制public void rotateByBrute(int[] nums, int k) {
int n = nums.length;
k %= n;
for (int i = 0; i < k; i++) {
int last = nums[n - 1];
for (int j = n - 1; j > 0; j--) {
nums[j] = nums[j - 1];
}
nums[0] = last;
}
}
这个解法在思路上没问题，但时间复杂度是 O(n * k)。当 n 和 k 都到 10^5 级别时，运算量会膨胀到 10^10，提交时直接超时。
它能提供的价值是帮助理解“右移一位”这个原子操作。在我的经验里，能写出这段代码说明基本逻辑通畅，但作为最终答案，面试官很难给你加分。所以你可以在纸上画一画这个思路，实际作答时跳过它，直接进入更优方案。
2.2 额外数组：最不容易出错的“标准答案”
如果你想在最短时间内写出一份百分百正确的代码，额外数组法是我推荐的首选。它的逻辑非常直白：新建一个数组 newArr，遍历原数组，把 nums[i] 放到 newArr[(i + k) % n]。遍历结束后，再把 newArr 整体拷贝回 nums。
java复制public void rotateByCopy(int[] nums, int k) {
int n = nums.length;
k %= n;
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)，对于通常 1 <= n <= 10^5 的题目数据完全能通过。
如果是在真实业务里做类似操作，我也会优先用这种“以空间换时间”的方案，因为工程代码追求可读性和正确性，而不是处处抠常数空间。但 LeetCode 这道题的重点考查目标之一，就是你能不能从 O(n) 空间优化到 O(1) 空间。
2.3 两种基础方案的时间与空间对比
| 解法 | 时间复杂度 | 额外空间 | 是否适合作为最终答案 |
|---|---|---|---|
| 朴素单步移动 | O(n * k) | O(1) | 否，大数据必挂 |
| 额外数组拷贝 | O(n) | O(n) | 可以作为兜底方案 |
| 三次反转 | O(n) | O(1) | 面试标准答案 |
| 环状替换 | O(n) | O(1) | 进阶加分项 |
我个人的建议是，先记住额外数组法，确保自己做题时不至于卡死；然后重点掌握三次反转。环状替换属于“你知道了会显得很厉害，不知道也不会扣分”的扩展知识点。
3. 三次反转：从“整体逆序”变成“局部换位”的精妙化简
3.1 为什么反转三次就能完成轮转
三次反转的代码非常短，但很多人只背步骤，不理解它背后的区间逻辑。这里我用最直白的方式拆一遍。
沿用前面把原数组记为 AB 的思想，A 是前 n-k 个元素，B 是后 k 个元素。数组轮转 k 位，等价于把 AB 变成 BA。
现在做一次整体反转。反转后数组变成 reverse(B) + reverse(A)，也就是 B^R A^R。
接着，反转前面那一段 B^R，它恢复成 B。再反转后面那一段 A^R，它恢复成 A。最终得到 B + A，恰好就是我们要的 BA。
三次反转的本质可以浓缩成这个关系式：
text复制(A^R + B^R)^R = B + A
反转操作本身就是原地交换，不需要额外数组，所以空间复杂度是 O(1)。这也是它成为“标准答案”的核心理由。
3.2 手动推演一个完整例子
用题目自带的例子：nums = [1,2,3,4,5,6,7], k = 3。
第一步，整体反转：
text复制[7,6,5,4,3,2,1]
第二步，反转前 k=3 个位置，也就是反转 [7,6,5]：
text复制[5,6,7,4,3,2,1]
第三步，反转剩余的后 4 个位置，也就是反转 [4,3,2,1]：
text复制[5,6,7,1,2,3,4]
结果正确。这个例子我建议你亲手在草稿纸上画一遍，体会下标的变化。画过之后再看下面的代码，会顺畅很多。
3.3 Java、C++、Python 的最佳实现
Java 里由于没有直接提供区间反转的库函数，需要自己手写一个 reverse 方法。这里注意我使用的区间是左闭右闭的，也就是 left 和 right 两个下标都会被反转。
java复制public void rotateByReverse(int[] nums, int k) {
int n = nums.length;
k %= n;
if (k == 0 || n <= 1) {
return;
}
reverse(nums, 0, n - 1);
reverse(nums, 0, k - 1);
reverse(nums, k, n - 1);
}
private void reverse(int[] nums, int left, int right) {
while (left < right) {
int tmp = nums[left];
nums[left] = nums[right];
nums[right] = tmp;
left++;
right--;
}
}
C++ 可以直接用标准库里的 std::reverse，迭代器区间是左闭右开，这是和 Java 手写版本最大的区别：
cpp复制void rotate(vector<int>& nums, int k) {
int n = nums.size();
k %= n;
if (k == 0 || n <= 1) return;
reverse(nums.begin(), nums.end());
reverse(nums.begin(), nums.begin() + k);
reverse(nums.begin() + k, nums.end());
}
Python 里如果面试允许 O(1) 额外空间，就写自定义的反转函数：
python复制def rotate(self, nums: List[int], k: int) -> None:
def reverse_range(i: int, j: int) -> None:
while i < j:
nums[i], nums[j] = nums[j], nums[i]
i += 1
j -= 1
n = len(nums)
k %= n
if k == 0 or n < 2:
return
reverse_range(0, n - 1)
reverse_range(0, k - 1)
reverse_range(k, n - 1)
3.4 区间开闭不一致是最容易踩的坑
这里的坑比想象中多。C++ 的 reverse(nums.begin(), nums.begin() + k) 反转的是 [begin, begin+k)，也就是下标 0 到 k-1，不包含第 k 个元素。如果你理解成“包含 end”，就会多反转一个数。
Java 手写版里我用的是闭区间，reverse(nums, 0, k - 1) 反转下标 0 到 k-1，末尾索引是 k-1。如果错写成 k，就会把本该属于后半段的第一个元素也卷进前半段反转，结果完全错误。
我见过不少人三种解法背得滚瓜烂熟，一运行就错在区间上。我的建议是选定一种语言后，把这段代码原样跑通三次，然后刻意把区间改错一次观察输出差异，印象会非常深。
4. 环状替换：当面试官不允许用 reverse 时的硬核解法
4.1 下标跳转图：为什么有的题解绕来绕去
额外数组法把每个元素放到目标位置，需要额外空间。三次反转法通过 reverse 实现原地操作。那如果面试官进一步追问：不借助 reverse 本身，有没有更偏纯下标移动的做法？
有，就是环状替换，也叫循环置换法。思路很简单：从某个起点开始，取出当前位置的值，计算它应该去的目标下标 next = (current + k) % n，把目标下标原来的值存起来，再把当前值填进去，然后移动到目标下标继续重复。直到回到起点，完成一个环。
举个小例子：nums = [1, 2, 3, 4]、k = 2。
如果从下标 0 出发：0 的值 1 放到下标 2，2 原来的值 3 需要继续处理；接着从下标 2 出发，2 的值 3 放到下标 0，0 原来的值是 1，但 1 已经被移走了。最后回到 0 时发现，只处理了 0 和 2 两个位置，下标 1 和 3 还没动过。
原因是 4 和 2 不互质，它们的最大公约数 gcd(4, 2) = 2，所以需要两个环才能覆盖全部元素：一个环是 0 -> 2 -> 0，另一个是 1 -> 3 -> 1。
4.2 为什么起点个数就是 gcd(n, k)
这是环状替换里最容易被忽略、也最值得讲清楚的地方。
每跳一步的后进步长是 k，下标在模 n 的意义下不断累加。从起点 0 出发，经历的所有下标是：
text复制0, k, 2k, 3k, ...（全部对 n 取模）
这个序列什么时候回到 0？当累计步数第一次等于 n / gcd(n, k) 时。也就是说，从一个起点出发，只能覆盖 n / gcd(n, k) 个下标。要覆盖全部 n 个下标，需要 gcd(n, k) 个不同的起点。
你可以把环想象成钟表，k 是每次走几格。如果表盘有 4 格，每次走 2 格，那只能在偶数格上打转，永远踩不到奇数格。必须把起点从偶数格换到奇数格，才能覆盖全部表盘。
这也是为什么很多错误版本“只写一个起点就能通过部分测试”：当 n 和 k 互质时，一个环确实能覆盖全部下标；但一旦 n 和 k 有公因数，代码就会漏掉一批元素。LeetCode 的测试用例覆盖很全，所以这种半吊子解法提交上去通常会在某个用例上原地翻车。
4.3 基于 gcd 的写法
先用辗转相除法求 gcd(n, k)，然后遍历 gcd 个起点，每个起点走一个完整的环。这里我用 Java 展示：
java复制public void rotateByCyclic(int[] nums, int k) {
int n = nums.length;
k %= n;
if (k == 0) {
return;
}
int cycles = gcd(n, k);
for (int start = 0; start < cycles; start++) {
int current = start;
int prev = nums[start];
do {
int next = (current + k) % n;
int tmp = nums[next];
nums[next] = prev;
prev = tmp;
current = next;
} while (current != start);
}
}
private int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
这里有一个编码细节：内层循环用的是 do...while，而不是 while。因为要确保起点位置的值最开始就被放到目标下标去，而不是先判断 current != start 导致一次都不执行。如果你写成 while 循环，需要额外处理边界，很容易把自己绕晕。
4.4 不依赖数论理解的替代写法
如果面试时一下子想不起来 gcd，还可以用计数来控制外层循环。每成功替换一个元素就让计数器加一，直到所有 n 个元素都被替换过。这种写法不依赖最大公约数，逻辑也更贴近“覆盖所有下标”的本质。
java复制public void rotateByCyclicWithCounter(int[] nums, int k) {
int n = nums.length;
k %= n;
if (k == 0) {
return;
}
int count = 0;
for (int start = 0; count < n; start++) {
int current = start;
int prev = nums[start];
do {
int next = (current + k) % n;
int tmp = nums[next];
nums[next] = prev;
prev = tmp;
current = next;
count++;
} while (current != start);
}
}
从纯工程角度看，第二种写法比第一种更不容易出错，因为它把“到底需要几个环”这个数论问题转变成了“替换够 n 次就停”的计数问题。不过在面试中，如果你能主动讲出 gcd 那层道理，会显得对算法本质理解得更深。我通常是两种都准备好了，先写 gcd 版本，然后在解释里带一句“也可以用计数代替 gcd 计算”。
5. 从代码细节到边界条件：那些容易写错的小地方
5.1 先取模，再考虑 k == 0 的提前返回
很多人在写 rotate 方法时，习惯一上来就判断数组长度是否为 0 或 1。更稳妥的顺序是：
- 先计算
n； - 然后
k %= n； - 再判断
k == 0或n <= 1，如果成立直接返回。
先取模的意义在于让后续所有逻辑都建立在 k < n 的基础上。比如 k = 0 时，三次反转里的 reverse(nums, 0, k - 1) 会变成 reverse(nums, 0, -1)，虽然手写反转函数里因为 left < right 不成立不会报错，但代码一眼看去很容易误导别人。最好的做法是在反转之前就 return，让逻辑分支清晰。
5.2 Java 传参是个引用陷阱
Java 方法签名的参数是 int[] nums，数组属于引用类型。你在方法里修改 nums[0]、nums[i] 这种操作，外部数组会同步变化，因为引用指向同一个对象。
但如果你写：
java复制nums = new int[n];
或者：
java复制nums = newArr;
那么只是让局部变量 nums 指向了一个新对象，外部原来的数组根本不会变。LeetCode 的判题逻辑是通过观察原数组内容来判断对错，所以这种写法会导致输出结果和输入一样，提交永远不通过。
Python 也有类似的问题。函数内执行 nums = nums[-k:] + nums[:-k]，只是让局部变量指向新列表，调用方持有的原列表并没有变化。
正确的 Python 写法是用切片赋值：
python复制nums[:] = nums[-k:] + nums[:-k]
这种写法会把右边新列表的内容逐项拷贝到原列表的内存区域，外部引用才能看到变化。
5.3 反转区间：闭区间 vs 开区间
前面提到过，Java 手写反转通常用左闭右闭区间，C++ std::reverse 用的是左闭右开区间。很多人在语言之间切换时容易搞混。
我提供一个自查方法：
- Java：
reverse(nums, 0, k - 1)表示要反转的元素区间是[0, k-1]。末尾下标减一，是因为要反转 k 个元素。 - C++：
reverse(nums.begin(), nums.begin() + k)，第二个参数是结束迭代器，指向最后一个要反转元素的下一个位置。所以begin() + k虽然“看着像越界”，但在左闭右开区间里恰好表示反转前 k 个元素。
如果你用 Python，我建议也自己写左闭右闭的 reverseRange(i, j)，不要用切片 nums[:k] = reversed(nums[:k])，因为切片会产生额外临时列表，空间复杂度就不再是 O(1)，和面试官要求冲突。
5.4 建议自测的几组边界用例
写完代码后，别急着交，先在脑子里过这几组用例：
| 输入 | k | 预期输出 |
|---|---|---|
[1] |
0 | [1] |
[1] |
5 | [1] |
[1, 2] |
3 | [2, 1] |
[1, 2, 3, 4, 5] |
0 | [1, 2, 3, 4, 5] |
[-1, -100, 3, 99] |
2 | [3, 99, -1, -100] |
第二组用例很容易被忽略。数组长度为 1 时，无论 k 是多少，结果都应该保持不变。三次反转和环状替换的代码里如果忘记先处理 n == 1，虽然运行起来不一定报错，但逻辑上不够严谨。
第五组用例是 LeetCode 给出的第二个示例。数组里包含负数，这不是问题——负数只影响元素值，不影响下标计算。这里专门列出来是想提醒你，数组内容本身不影响算法正确性，别因为看到负数就疑神疑鬼。
5.5 手写 reverse 时的空转问题
在 Java 的手写反转函数里，while (left < right) 天然处理了空区间和单元素区间。如果 left 已经大于 right，循环不会执行。
有些写法会用 for (int i = left; i <= (left + right) / 2; i++)，这种写法在区间为空的场景下要特别注意：如果 right 是 -1，left + right 会变成负数，再除以 2，依然可能是负数，循环可能一次都不执行，也可能因为边界条件写歪而越界。
所以我的习惯是统一用 while (left < right)。它最简单，也最难写错。
6. 迁移练习与面试表达：189 题背后的通用思维
6.1 一鱼多吃：轮转思想还能用在哪
189 题的三次