lnstagram优选作为一个常年刷 PTA 的“老油条”，我印象里最容易被新手翻车的基础题，B1008 的“数组元素循环右移问题”绝对排得上号。题目本身只有一句话：“把数组往右转 M 个位置”，看起来比排序、查找简单太多，但真上手提交，很多人会在 M 比 N 大、末尾空格、原地操作这几个坑上反复罚时。这篇就把这道题从题目本质到三种主流解法一次讲透，顺便聊聊它怎么延伸到字符串逆序、单词翻转、二分查找这些热门题上。
如果你正在刷浙大 PTA 基础题，或者刚学完数组想找一道“看着简单做起来能卡住人”的练手题，这篇很适合你；就算你已经 AC 了，也可以看看取模输出法和三次反转法在工程场景里的取舍差异。
1. 题目到底在问什么：为什么“循环右移”不是简单平移
1.1 输入输出和表面要求
先复述一下常见的题目描述。假设数组 A 里有 N 个整数，比如 [1, 2, 3, 4, 5]，N=5。现在要求每个整数循环向右移动 M 个位置，注意是“循环”，不是直接平移后把末尾元素丢掉。右移 2 位后，末尾的 4, 5 会跑到最前面，得到 [4, 5, 1, 2, 3]。如果 M=0，那就是原样输出。
输入一般是两行：第一行给 N 和 M，第二行给 N 个整数。输出要求把右移后的数组打印出来，元素之间用空格分隔，并且行尾不能有多余空格。这最后一句话，就是 PTA 判题最严格的点，后面会专门讲。
1.2 循环移动的本质：把数组拆成两段再换位置
从数据结构角度看，一次循环右移 M 位，可以这样理解：原数组看成 A + B 两段，其中 A 是前 N-M 个元素，B 是后 M 个元素，右移后的结果就是 B + A。比如 [1,2,3,4,5]，M=2 时，A=[1,2,3]，B=[4,5]，目标是 [4,5,1,2,3]，也就是交换 A 和 B 这两段的位置。
一旦想明白这一点，整个题其实就变成“如何把一个序列的两段互换位置”。这也是所有高效解法的底层逻辑。新手最容易犯的错，是陷入“一个一个挪”的细节里：先保存最后一个元素，然后把前面所有元素往后挪一位，再把保存的元素放到开头，如此重复 M 次。这种方法不是不能 AC，但代码写起来容易在边界上出 bug，而且如果哪天 N 和 M 的数据范围变大，这种暴力方式会被时间卡得很惨。
1.3 隐藏条件：M 可能比 N 大
题目说 M 是一个非负整数，但并没说 M 一定小于 N。如果 N=5，M=12，循环右移 12 位和右移 12 % 5 = 2 位是等价效果。为什么？因为每右移 N 位，数组就会回到原始状态，所以真正的有效移动次数只有 M % N 次。很多人一上来直接写 for k in 0..M，结果 M 取 100 时虽然也能跑，但代码逻辑已经不对了，更别说 PTA 里有些测试点专门用 M > N 来卡人。先对 M 做取模，是解这道题第一个必须做的事。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 最优解法：三次反转法的完整推导与细节
2.1 为什么反转三次就能让两段位置互换
前面把右移抽象成“把 A+B 变成 B+A”。假设我们要把 [1,2,3,4,5] 变成 [4,5,1,2,3]，最简单的方法之一就是三次反转。这里我用“整段反转再分别反转”的经典流程：
第一次：把整个数组反转，得到 [5,4,3,2,1]。这一步之后，原始的 B 段反转后到了数组开头，原始的 A 段反转后到了数组末尾。
第二次：反转数组前 M 个元素。前 M 个当前是 [5,4]，反转后变成 [4,5]。于是数组变为 [4,5,3,2,1]。
第三次：反转数组剩余 N-M 个元素，也就是 [3,2,1]，反转后变成 [1,2,3]。最终结果 [4,5,1,2,3]。
这个过程看起来很奇妙，背后的原理其实不复杂。反转操作有一个性质：连续做两次相同的反转会回到原状态。我们对整个数组做一次反转，相当于把原序列顺序倒置，而两段内部也各自倒置；接着分别对两段再反转一次，正好把两段内部的顺序恢复回来，同时两段在前一次整段反转中已经互换了绝对位置。用数学式子表达就是：原序列 AB，全部反转得到 rev(B) rev(A)，前段反转得到 B rev(A)，后段反转得到 B A，完成目标。
2.2 反转边界设计：闭区间还是半开区间
三次反转的代码实现里，最容易写错的是下标。如果你写一个 reverse(int a[], int left, int right) 函数，表示反转下标 [left, right] 闭区间内的元素，那么调用方式为：
- 整体反转：
reverse(a, 0, N-1) - 反转前 M 个：
reverse(a, 0, M-1) - 反转后 N-M 个：
reverse(a, M, N-1)
操作里 while (left < right)，两边不断交换并向中间靠拢。需要注意的是，这个 M 必须提前取模过，否则第二步的 M-1 可能越界。如果一开始 M 就是 0，第二步 reverse(a, 0, -1) 会进入死循环或抛异常，所以推荐先处理“M 为 0 直接原样输出”的情况，或者把反转函数写得更健壮，但更推荐在 main 里直接判断。
2.3 C 语言完整代码示例
下面是我在 PTA 提交过的 C 语言版本，关键路径很短，注释里写清楚了每一步的含义：
c复制#include <stdio.h>
void reverse(int a[], int left, int right) {
while (left < right) {
int tmp = a[left];
a[left] = a[right];
a[right] = tmp;
left++;
right--;
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
int a[105];
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
m = m % n;
if (m != 0) {
reverse(a, 0, n - 1);
reverse(a, 0, m - 1);
reverse(a, m, n - 1);
}
for (int i = 0; i < n; i++) {
if (i > 0) {
printf(" ");
}
printf("%d", a[i]);
}
printf("\n");
return 0;
}
运行一下，输入：
code复制6 2
1 2 3 4 5 6
第一步整段反转得到 [6,5,4,3,2,1]，反转前 2 个变成 [5,6,4,3,2,1]，再反转后 4 个得到 [5,6,1,2,3,4]。结果和题目要求一致。注意这里所有操作都在原数组上完成，没有额外开数组，既满足“不允许使用另外数组”的要求，也把时间复杂度稳定控制在 O(N)。
3. 取模输出法：一种更“偷懒”但很实用的思路
3.1 不修改数组也能过题的关键
三次反转法虽然很标准，但在 PTA 这道题里，还有一个更取巧的思路：既然数组本身不动也能通过改变遍历顺序来模拟移动效果，那我为什么非要真的去移动元素？循环右移 M 位后，数组新的顺序等于先输出原数组中后 M 个元素，再输出前 N-M 个元素。只需要在输出时让下标从 N-M 开始遍历到 N-1，然后从 0 遍历到 N-M-1 即可。
对应 C 代码可以写成：
c复制m = m % n;
for (int i = n - m; i < n; i++) {
printf("%d ", a[i]);
}
for (int i = 0; i < n - m; i++) {
if (i == 0 && m == 0) {
printf("%d", a[i]);
} else {
printf(" %d", a[i]);
}
}
不过这样写很容易在空格控制上翻车，所以我更推荐把输出逻辑统一放到一个循环里：先确定一个起点 start = n - m（注意 M 对 N 取模后 M 可以与 N 相等为 0），然后用取模的方式访问数组：
c复制m = m % n;
for (int k = 0; k < n; k++) {
if (k > 0) {
printf(" ");
}
printf("%d", a[(n - m + k) % n]);
}
printf("\n");
这样做的好处是数组完全没动，也可以看作是一个“逻辑上已经移动”的顺序。比如 N=5，M=3，start = 2，输出序列为下标 2,3,4,0,1，对应元素会呈现右移 3 位的效果。这个办法的空间复杂度是 O(1)，时间复杂度是 O(N)，因为每个元素都只访问一次。
3.2 为什么我建议新手优先掌握三次反转而不是取模
从刷题功利角度，取模输出法完全能 AC，代码还短，但如果你打算靠这道题锻炼算法思维，我还是建议把三次反转吃透。原因有三点。第一，取模输出法是“绕过问题”而不是“解决问题”，它只在输出层面模拟了循环移动，一旦题目改成“必须修改数组且后续操作依赖数组的新状态”，这个思路就失效了。第二，三次反转的思考过程能迁移到更多场景，比如字符串整体翻转、单词顺序翻转、旋转数组里的二分查找，它们的内核都是“对段做反转来调整顺序”。第三，实际工程里数组往往是真实容器，你需要的是把元素真正挪到目标位置，而不是在遍历时算一个偏移量。
当然，如果纯粹为了在 PTA 上通过时间限制很紧的单道题，取模输出法也是一种可复用的技巧。只是它不应该成为你脑子里的唯一解法，否则遇到同类题会少一条路。
3.3 输出末尾空格：PTA 判题最常见的扣分点
无论用哪种方法，输出格式都是必须处理好的部分。常见错误有两种：每个元素后都加一个空格，导致行尾多一个空格，PTA 通常会判 Presentation Error，甚至是 Wrong Answer；每个元素前都加一个空格，但第一个元素前没有空格，这个做法本身没问题，唯一要注意的是第一项前面不要有空格。
最稳妥的格式控制方式就是在输出循环里加一个条件：除了第一个元素外，每输出一个元素前先打一个空格。C 语言里写成 if (i > 0) printf(" "); 就可以了。不要把换行符和空格混在一起写，否则 M=0 或者 N=1 时容易出问题。我见过不少同学在 N=1 的特殊测试点上翻车，因为只有一个元素时，无论循环怎么写，行首行尾都不能有多余空格。用统一的空格前缀写法，这类边界情况能自动规避。
4. 从暴力到 AC：一次完整的实际踩坑复盘
4.1 第一版暴力解法的崩溃点
我最初刷这道题时，思路很简单：每右移一次，就先把最后一个元素存进临时变量，然后把整个数组从后往前依次后移一位，最后把临时变量放回数组开头。核心代码大概是：
c复制for (int j = 0; j < m; j++) {
int tmp = a[n - 1];
for (int i = n - 1; i > 0; i--) {
a[i] = a[i - 1];
}
a[0] = tmp;
}
这个版本的逻辑在 M 比较小时是对的。可问题就出在“M 比较小”上。第一次提交我把 m 直接用，没有取模。测试数据里如果出现 N=10、M=99999，内层循环要执行 10 万次，而且每次都要把整个数组搬运一遍，整体就变成 O(N×M)。虽然 PTA 的 B1008 数据范围看起来不大，N 可能只有 100，但 M 并没有上限，这样暴力写法轻则超时，重则逻辑直接错误。后来我才意识到，第一步必须先把 m %= n，否则后面所有讨论都建立在错误的移动次数上。
4.2 用特殊输入自测边界问题
写完取模后我遇到过另一个情况：当 M=0 或者 M 是 N 的整数倍时，数组不需要变化，但我的暴力代码里第二层循环没有判断 m 是否为 0，导致进入 for (int j = 0; j < 0; j++)，这倒是不会执行，所以没有报错，但后面的三次反转版本里，如果不加判断，就会调用 reverse(a, 0, -1)，直接陷入死循环或数组越界。
后来我养成了一个习惯：任何数组题，先测三个特殊输入。第一个是 N=1, M=任意非负整数，因为此时循环右移任何位数结果都只有自己，这一条能卡住很多下标计算错误；第二个是 M=0；第三个是 M=N 或 M=2*N，用来验证取模是否生效。这三个输入过了，至少边界上的大坑就能排除。
4.3 PTA 提交时的细节：scanf 与测试样例
PTA 判题不会展示完整输入，所以你必须老老实实地用 scanf 读取两个整数，再循环读取数组。有些人可能会用 while(scanf("%d", &x) != EOF) 的方式读取，但对于这种固定格式题目，直接读取两轮更清晰。另外，数组长度建议稍微开大一点，比如题目说 N≤100，你就开 a[105] 甚至 a[110]，别开 a[100]，否则万一数组下标访问到边界，本地可能不报错，提交后却可能出现随机性内存错误。这种问题最难排查，不是语法错误，而是未定义行为。
还有一个小建议：在本地调试时，输出结果后可以手动比对样例，但在 PTA 上提交时，不要把调试用的 printf 留在代码里。有些同学喜欢打日志看中间数组，最后忘删，结果输出里多了一堆额外字符，直接错得莫名其妙。
5. 和其他 PTA/热门题目的关联：不止 B1008 这一道
5.1 LeetCode 189 轮转数组和 B1008 的异同
如果你刷过 LeetCode，会发现第 189 题“轮转数组”几乎就是 B1008 的姊妹题，只是 LeetCode 把 M 改名为 k，而且要求更严格：必须原地修改数组，空间复杂度为 O(1)。B1008 里取模输出法还能侥幸通过，LeetCode 189 的评测逻辑会比对这个数组，你只改变输出顺序是不行的。所以如果你已经理解了 B1008 的三次反转法，那么 LeetCode 189 对你来说就是一道“换个包装”的题；反过来，如果你只掌握取模输出法，到了 LeetCode 就会卡壳。这也是为什么前面我反复强调要吃透真实翻转数组的方法。
5.2 从循环右移到字符串逆序和单词翻转
PTA 里还有几道经典题，比如“字符串逆序”，本质是反转整个字符数组，只要写一个对字符数组的 reverse 就能搞定。再比如“单词翻转”，题目会给你一句英文句子，要求把单词顺序反转，但单词内部的字符顺序不变。处理思路也很流程化：
- 先把整个字符串反转，这样一来单词本身也反转了，但单词的相对顺序反过来了。
- 再把每个单词内部单独反转回来。
这其实就是三次反转在字符串上的变体：整体当做一个数组，单词当做一个段。学了 B1008 的“局部反转”思想后，再看单词翻转，会很有亲切感。还有更进阶的，比如“拼接字符串实现整体翻转”的技巧，也可以用同样的分治法去理解。
5.3 旋转数组与二分查找的结合
热搜里还有“二分查找 pta 函数”这种词，很多人学完二分查找后会遇到一个经典变体：在一个被旋转过的有序数组里找目标值。比如数组原来是 [1,2,3,4,5,6,7]，循环右移 3 位后变成 [5,6,7,1,2,3,4]，此时整个数组不再是单调递增，但我们可以观察到，它总是可以被分为两段，其中至少有一段是完全有序的。二分时，先判断 mid 落在哪一段，再根据 target 和边界值的关系决定往左还是往右搜。如果你能熟练画出 B1008 里数组循环移动后的下标关系，就会发现旋转数组的“断点”其实就是右移的 M，而所有下标转换都能通过取模来完成。这再次验证了数组循环移动不是一道孤立的简单题，它经常作为更复杂题目的前置知识出现。
6. 刷题习惯与实战建议
说回 B1008 本身。当你把三次反转和取模输出两种方法都写过之后，会发现自己对数组下标和区间反转的理解明显深了一层。我在实际指导别人刷题时，经常会让他们把这道题用三种方式实现：第一种是暴力逐位移，第二种是三次反转，第三种是取模输出。目的不是为了炫技，而是让你亲眼看到同一个问题可以有完全不同的建模角度。暴力法教会你“模拟过程”；三次反转教会你“观察结构”；取模输出教会你“分析需求边界”。这三种角度，在不同场景下各有价值。
做题时还要养成一个习惯：先思考十分钟再动手。B1008 这种难度，其实十分钟已经够把几个关键点都想到。真正拉开差距的不是你会不会写 reverse，而是能不能一次考虑到 M 取模、M 为 0、末尾空格这些边界。如果在本地测试时能自己构造几个极端用例跑一遍，提交时就会比绝大多数人稳很多。
从这道题延展出去，字符串类的“单词翻转”、数组类的“轮转数组”、技巧类的“旋转数组二分”，本质都在玩“段”的交换。你把 B1008 的数组下标关系吃透，后面遇到这类变化，就不需要重新啃一遍，只要在已有框架上换一下数据处理逻辑。这也是我觉得它值得认真写一篇博文的原因。
最后说一个我自己的小技巧：在实现三次反转时，不要写三个裸循环去手动交换，最好提取成 reverse 函数，然后把调用的顺序和区间写对。这个习惯能让你在代码量更大时依然保持清晰，也能方便你在本地调试时单独测试每一步的结果。比如用 gdb 或者在 reverse 函数里临时打印数组，能更快定位是整体反转出了问题，还是局部反转的边界不对。调试完记得删掉打印语句，剩下的就是一份干净的 AC 代码。