1. 题目拆解：数组循环左移到底在考什么
1.1 读懂题目描述
习题2.2的题面通常就一句话：给定一个长度为n的数组，将其循环左移k位，返回结果。比如数组[1, 2, 3, 4, 5]左移2位，结果是[3, 4, 5, 1, 2]。看起来简单，但真要动手写，很多人会卡在“循环”这个词上——移出去的元素不是丢掉，而是从数组尾部重新进来。这个动作在逻辑上等价于：把数组前k个元素整体挪到数组末尾，其他元素依次向前补位。
我第一次接触这个题目时，第一反应是“这有什么好写的”，直接arr[k:] + arr[:k]一行完事。但在真正的教学中，这类题恰恰是面试和算法入门最喜欢用的题目。原因很简单：它考察的不是题面难不难，而是你能否在限制条件下把时间复杂度和空间复杂度都照顾好。
我在辅导某位同学时，对方最开始写的是：
def left_rotate(arr, k): for _ in range(k): temp = arr[0] for i in range(len(arr) - 1): arr[i] = arr[i + 1] arr[-1] = temp这段代码逻辑没有错，但它把问题变成了“移动k轮、每轮移动n个元素”，复杂度是O(n×k)。当n和k都很大的时候，运行时间会非常难看。这道题真正想教会你的，是怎么把O(n×k)一步步优化到O(n)，再到既O(n)时间又O(1)空间。这背后涉及的是“怎么看待一个已知解法，然后找到它的瓶颈并突破”的思维习惯，比题目本身值钱得多。
1.2 为什么这个考点值得深挖
循环左移的价值不是这个动作本身，而是它作为“数组操作基本功”的浓缩标本。学会这道题，等于一次掌握了数组切片、取模、原地交换、反转子数组、循环块推进等多种技巧，这些在后续的排序、滑动窗口、旋转矩阵等问题里都会反复出现。
举个实际的例子：很多数据处理的场景里，需要把最近k条记录滚动展示，本质上就是个循环左移的变种。再比如，某跨平台系统的日志模块里，环形缓冲区写入数据时，移动逻辑就是数组循环移位。不是只有刷题才用得上。
更重要的是，这道题的三种典型解法——暴力法、额外数组法、三次反转法——恰好代表了算法设计的三个层次：
- 直接模拟，能跑，但开销大；
- 用额外空间换时间，思路清晰，但空间成本没压低；
- 通过数学规律和原地震荡，把两个指标都压到最优。
能把这三级梯度讲清楚，比单纯记一个解法有用得多。下面我会把这三种方案逐一拆开，再从边界条件、进阶算法、常见bug三个维度继续深入。
2. 三种主流实现：从暴力到最优
2.1 暴力移动法：最直观但最容易踩性能坑
先看暴力法。它的思路非常直接：左移1位，就是把arr[0]暂存起来，然后所有元素前移一位，最后把暂存的元素放到末尾。需要左移k位，就重复这个过程k次。
我在1.1里给出的代码就是标准写法。这种方案的正确性很容易验证，新手理解起来零门槛，但性能是硬伤。假设数组长度为10万，左移5万次，每次要搬动10万个元素，总共5×10^9次操作，跑完要好几秒。
更隐蔽的问题是重复代码里隐藏的边界错误。比如很多人写内层循环时，习惯用for i in range(len(arr) - 1)，如果写成range(len(arr))，就会出现索引越界，或者把arr[i + 1]读到了不存在的下标。我在调试时看过某位同学把内层循环的终止条件写成len(arr)，结果阴差阳错地“成功”把数组全变成了同一个值——这类bug调试起来非常迷惑。
那暴力法就一无是处吗？也不是。它的意义在于：
- 代码与题目的文字描述一一对应，适合作为对照基线；
- 当k特别小（比如k=1或2），并且n不大时，暴力法反而没有额外空间开销，代码也足够简单，工程上完全可用；
- 它还是验证另外两种高效方案正确性的“参照物”。
所以我的建议是：不要跳过暴力法，但也不要停留在暴力法。把它当作理解和验证工具，最终还是要往前推进。
2.2 额外数组法：用空间换时间的典型思路
暴力法慢的本质在于，每移动1位都要把整个数组重新搬一遍，重复k次。如果换个思路：先把数组拷贝一份，然后直接计算每个元素应该落到哪个位置，一步到位，是不是快很多？
计算公式很直接：原下标i的元素，在左移k位之后，应该到达新下标(i - k + n) % n。如果下标为负，取模后会自动转正。比如n=5、k=2，原下标0的元素，(0 - 2 + 5) % 5 = 3，也就是arr[0]要放到新数组下标3的位置。整体结果验证一下：[1,2,3,4,5]左移2位，新数组下标是[3,4,0,1,2]对应的原下标，得到[3,4,5,1,2]，正确。
代码上，我推荐两种写法，读者按自己习惯选：
def left_rotate(arr, k): n = len(arr) k = k % n temp = [0] * n for i in range(n): temp[(i - k + n) % n] = arr[i] return temp或者更Pythonic的切片法：
def left_rotate(arr, k): n = len(arr) k = k % n return arr[k:] + arr[:k]这段代码最容易让人忽略的是必须处理k > n的情况。如果数组长度是5、k是12，直接切片会得到arr[12:]和arr[:12]，前者是空列表，后者是全部元素，结果是[1,2,3,4,5]，看起来“没变”，但实际上是错的，真实结果是[3,4,5,1,2]。先取模k = k % n，保证k在有效范围内。
额外数组法的时间复杂度是O(n)，空间复杂度也是O(n)。它在工程上其实已经足够好了，毕竟大多数场景都不缺这一块内存。但面试或竞赛里如果追加一句“只能使用O(1)额外空间”，那就得用下一节的三次反转法。
2.3 三次反转法：原地解决的最优解法
三次反转法的原理非常巧妙，一句话概括：先把数组分成前后两段，分别反转这两段，最后把整个数组反转回来，左移就完成了。
具体的三个步骤：
- 反转前k个元素；
- 反转后n-k个元素；
- 反转整个数组。
拿[1,2,3,4,5]、k=2举例：
- 首先反转
[1,2]，得到[2,1]； - 然后反转
[3,4,5]，得到[5,4,3]，此时数组是[2,1,5,4,3]； - 最后整体反转，得到
[3,4,5,1,2]。
结果和预期一致。这个方法其实是借鉴了“字符串反转”的经典技巧——把两个子段各自逆序，再整体逆序，就能把两段互换位置。你不用死记步骤，抓住“两段互换”这个本质就够了。
实现起来也很简单，首先要写一个通用的反转函数：
def reverse(arr, left, right): while left < right: arr[left], arr[right] = arr[right], arr[left] left += 1 right -= 1然后三次调用：
def left_rotate(arr, k): n = len(arr) if n == 0: return arr k = k % n reverse(arr, 0, k - 1) reverse(arr, k, n - 1) reverse(arr, 0, n - 1)这里最需要注意的是边界下标：第二次反转是从k开始，不是从k+1开始。如果k已经取模过，那k一定在[0, n-1]范围内，不会出现越界。但如果k等于0，第一次reverse(arr, 0, -1)会直接跳过，因为left=0、right=-1不满足left<right，函数不会执行。第三次reverse(arr, 0, n-1)会整个反转一遍再反转回来，白白多一次操作，所以可以在开头加一个if k == 0: return arr提前退出，省掉无谓的开销。
三次反转法的时间复杂度是O(n)，空间复杂度是O(1)，因为反转操作全部在数组内部交换完成。这是这道题的标准最优解之一，面试时写出这个方案基本能赢得好感。但别高兴太早，真正拉开差距的是“能不能解释清楚为什么这样对”，而不只是背代码。
3. 边界条件与取模技巧：代码健壮性的关键
3.1 k大于数组长度怎么办
这个问题属于“必考边界”，在一些在线评判平台的测试用例里几乎是必现的。很多初学者第一版代码直接arr[k:] + arr[:k]，遇到k > n就翻车。原因我在2.2里已经分析过了。解决办法就是统一取模：
k = k % n取模的本质是：循环左移n位等于没移，移动2n位也等于没移。因为数组长度是n，左移n次正好转一整圈回到原位。所以不管k多大，实际真正需要移动的只有k除以n的余数部分。
特别提醒：取模必须写在任何使用k的代码之前。如果先用了arr[k:]再取模，等于白取。我见过不止一次这样的代码：函数开头没取模，等到算新下标时才取模，结果切片那行已经错了。
3.2 负数和零的特殊处理
题目一般不会明确说k非负，但实际要考虑到。k为负数时，语义上等于右移-k位，因为左移负数和右移正数是等价操作。比如左移-2位，其实就是右移2位，结果相当于左移n-2位。
那代码要怎么处理？最简单的方式是把负数转正：
k = k % nPython的取模有个特性：结果一定非负。(-2) % 5 = 3，自动帮你把负左移转换成等价的正左移。这一点Python比其他语言省心，C或Java里取模可能是负数，需要手动加n再取模。写C的读者用这个公式：k = (k % n + n) % n。
k等于0的情况前面提过，直接返回原数组即可。虽然不加判断也不会错，但能少做两次反转就少做两次，别小看这O(n)的差距——在n很大的时候，一个多余的整体反转就是百万级的元素搬动。
另外一种容易忽略的边界是n=0或n=1：
- n=0时，任何操作都应该直接返回空数组，否则取模会抛“除零错误”；
- n=1时，数组只有一个元素，不管k是多少，结果都一样。取模后k=0，逻辑上自动正确。
这些边界看着琐碎，但在实际工程里，输入数据什么千奇百怪的情况都有。轮询队列为空、日志缓冲只有一条记录、滚动数组大小为1——都对应着这些边界场景。提前把边界处理写好，比上线后打补丁省心得多。
3.3 下标换算公式的推导与记忆
额外数组法里用到的公式(i - k + n) % n，很多人在考场上会临时推导，不如平时就把它彻底想透。
设原数组下标是i，左移k位后，元素的新下标是j。因为左移是每个元素向前走k步，所以j = i - k。这个值可能为负，比如原下标0、k=2时，j = -2，意思是这个元素应该“越过”数组开头，绕到末尾去。为了把负数转成有效下标，加上n再取模，就得到(i - k + n) % n。
为什么加n再取模就等效于循环？因为数组下标的“绕圈”本质上是模n的数学运算：下标永远在[0, n-1]这个周期内。所谓循环左移就是每个下标减去k后对n取模所得的新下标。把这个问题理解成“模运算”而不是“物理搬动”，后面学哈希表和循环队列会更轻松。
我还有一个记忆技巧：反方向想。右移k位的公式是(i + k) % n，左移就是把加变成减，再处理负数。只要会写右移，左移就不会错。
4. 进阶挑战：原地环形替换算法
4.1 环形替换的核心原理
三次反转法虽然已经是最优复杂度，但它需要整体反转三次，常数项不小。还有一个更“硬核”的原地算法——环形替换，它连反转都不用，直接按“元素应该去的位置”逐个移动，逻辑更底层，也更考验对循环节的理解。
核心思想是：从某个起始位置开始，把当前元素取出，放到它应该去的新位置，再把新位置原有的元素取出，继续放到下一个位置……这样沿着一条“置换环”走，直到回到起始位置。每完成一步，当前位置就被正确填上，且不会占用额外空间。
用[1,2,3,4,5]、k=2演示：
- 从下标0开始，取出1，把它放到下标
(0-2+5)%5=3。此时下标3的元素是4，被取出来，填入1； - 带着4继续走，4的新位置是下标
(3-2+5)%5=1。下标1的元素2被取出，填入4； - 带着2继续走，2的新位置是下标
(1-2+5)%5=4。下标4的元素5被取出，填入2； - 带着5继续走，5的新位置是下标
(4-2+5)%5=2。下标2的元素3被取出，填入5； - 带着3继续走，3的新位置是下标
(2-2+5)%5=0，正好回到起点，把旧1的位置填上3。一个环走完。
最终数组是[3,4,5,1,2]，和三次数反转法结果一致，但全程每个元素只移动了一次，非常高效。
4.2 GCD与循环周期
上面这个例子恰好一个环就覆盖了所有元素，但不是所有情况都这么巧。如果n=6、k=3：
- 从下标0开始，序列是0→3→0，走了两步就回到原点；
- 下标1→4→1，也是一步就绕回来；
- 下标2→5→2，同理。
这说明整个数组被分成了多个互不相交的“环”，每个环的长度不同。环的个数和长度由n和k的最大公约数决定：环的个数等于gcd(n, k)，每个环的长度等于n / gcd(n, k)。
直观理解：移动k位，等价于下标加上k（注意方向，但周期结构一样）。如果gcd(n,k)=g，那么0、k、2k……这些下标在模n意义下只能走到那些与0的差是g的倍数的位置。所以这些位置构成一个环，起点0只负责其中一簇，其他簇的起点依次是1、2、…、g-1。
实现时，外层循环从0到g-1依次启动每个环：
def left_rotate(arr, k): n = len(arr) if n == 0: return arr k = k % n g = math.gcd(n, k) if g == 0: return arr for start in range(g): current = start prev = arr[current] while True: next_pos = (current - k + n) % n temp = arr[next_pos] arr[next_pos] = prev prev = temp current = next_pos if current == start: break return arr这个while循环里的退出条件current == start，对应“回到起点”，这是环形替换最容易出bug的地方。写成不满足条件才继续，很容易漏判或者死循环。我第一次实现时，就没有先判断next_pos == start就break，结果把最后一个元素漏掉了，整个数组错位一位。
判断gcd的作用也可以用来优化三次反转：如果g等于1，说明整个数组只有一个环，从下标0出发就能全部覆盖；如果g大于1，要保证每个环都被走到，这是必须的。理解了gcd，才算是真正理解了环形替换算法。
5. 常见问题与排查实录
5.1 几个高频Bug与调试思路
我在带学生和做项目时，反复遇到几个问题，列出来给大家对照排查。
第一个Bug：取模放错位置。有位同学先把k用了再取模，切片出来的结果和预期完全不对。排查方法很简单，在函数开头打印k，看是否已经在[0, n-1]范围内。如果第一步就取模，后面所有逻辑都基于合法值，很多错误自然消失。
第二个Bug：反转边界差一位。三次反转法里，第一次反转[0, k-1]、第二次反转[k, n-1]，我见过有人把第二次写成[k+1, n-1]，结果中间元素漏掉了。调这种bug最快的方式是用纸笔手动模拟一个小数组，比如[1,2,3,4]加上k=2，一行行对应看下标的移动，很快就能定位。
第三个Bug：贪图一行切片，忽略了内存复制。Python的arr[k:] + arr[:k]在新数组里做，虽然写起来舒服，但内存开销是O(n)。如果面试官要求原地，这个答案会减分。它的优点是可读性极好、性能也不错，能否使用要看题目限制。
第四个Bug：没有处理一致性。左移和右移方向搞混。我自己就经常下意识写成(current + k) % n，这是右移的公式。左移必须用减法。你可以记住：左移（向前移动）等于下标变小，右移（向后移动）等于下标变大。
5.2 题解速查与复杂度对照
我把每种方案的代码、优缺点和适用场景整理成一个速查表，平时备着，写的时候直接对照：
| 方案 | 时间复杂度 | 空间复杂度 | 代码难度 | 适用场景 |
|---|---|---|---|---|
| 暴力逐位移动 | O(n×k) | O(1) | 极低 | k很小、n很小、验证用 |
| 额外数组切片 | O(n) | O(n) | 极低 | 内存充足、代码要短 |
| 三次反转 | O(n) | O(1) | 低 | 面试/竞赛标准解法 |
| 环形替换 | O(n) | O(1) | 中高 | 追求极致性能、理解循环节 |
这里要提醒一点：时间复杂度表里的O(n×k)不代表一定慢。如果n为100、k为1，暴力法照样飞快。复杂度分析描述的是“增长趋势”，不能脱离具体的n和k谈性能。遇到这类“哪个方案更优”的问题，先看规模，再谈复杂度。
5.3 扩展：从数组到链表的循环移位
掌握数组循环左移后，很多读者会问：如果数据结构换成单链表，怎么做？
链表不能随机访问下标，但思路可以复用：找到第k个节点作为新头，然后把链表尾部和头部接起来，再把新的尾节点断开。具体步骤是：
- 先遍历一遍链表算长度n；
- 对k取模；
- 走到第n-k个节点（新的尾节点），记录它的下一个节点为新头；
- 把链表的最后一个节点的next指向原头；
- 把新尾节点的next置为None。
这个操作只需要常数空间，时间复杂度O(n)，和三次反转法效率相当，但实现里非常容易在“断链位置”上出错。链表这里就不展开写了，但有心人会发现，它其实就是取模和下标思想在另一种数据结构上的延伸。
我自己带过的几位同学，在把数组解法迁移到链表的练习里，一致反馈“原来循环移位的思想是通用的”。确实，底层都是模运算和环形结构，数据结构变了，思路不变。
回到这道习题本身。它最值得花时间的地方，不是把某一版代码背下来，而是把暴力法、额外数组法、三次反转法、环形替换法都亲手写一遍，再对比它们的差异。写完之后，你会发现自己对数组下标的敏感度、对取模运算的理解、对原地算法的直觉，都有了一次实打实的提升。我在实际辅导中看到的最多的进步，恰恰就是从“只知道切片一行搞定”到“能讲清为什么三次反转是对的”这个转变。这不只是一道习题，它是一个可以反复咀嚼的算法思维训练场。
