PTA B1008数组循环右移问题全解析：从暴力解法到三次反转法

明知是道基础题，我还是想认真聊聊PTA B1008这道“数组元素循环右移问题”。

为什么？因为这题在PTA乙级里非常典型：题目本身不难，但坑一点都不少。你上网一搜“PTA B1008”，能看到大量讨论都集中在“为什么我最后一个测试点过不了”“为什么移动0位还要输出空格”这类问题上。很多新手在这道题上卡住，不是不会写循环，而是没真正想清楚“数组右移”的几个细节边界。这篇文章我就把这题从题意、解法到常见坑一次说透，权当是自己刷题时踩坑记录后的整理。

这道题面向的读者很明确：正在刷PTA乙级、准备C语言考试或刚学完数组想找点题目练手的同学。你能从这篇文章里得到的不只是一份 AC 代码，更重要的是怎么在脑子里把“循环右移”模型拆清楚，以后遇到这类“假装要移动、实际考输出”的题目，一眼就能看穿。

1. 题目到底在考什么

先复盘一下题目本身。

题目要求接收一个长度为 N 的数组，再给出一个整数 M，要求把数组元素循环右移 M 个位置，最后输出移动后的结果。什么叫“循环右移”？就是每次移动时，数组末尾的元素跑到开头，其余元素依次往后挪一位。移动 M 次就是重复这个过程 M 回。

很多同学第一次看到这题，第一反应是：这不就是数组平移吗？于是立刻就开始写两层循环，外层控制移动次数，内层控制每个元素的移动。逻辑看起来天经地义，提交的时候也觉得自己没问题，但实际跑起来，问题就来了。

1.1 核心考点并不是“移动”本身

这题真正的第一个考点藏在题目约束里：题目并没有硬性要求你必须真的移动数组里的元素，最后可能只期待你输出移动后的序列。这种“题目说的是移动，实际考察的是输出格式和数据组织”的出题思路，在PTA早期题目里很常见。它设置的陷阱也很有趣：即使你完全不移动数组，只要按照正确的起点偏移量遍历输出，一样能通过。

第二个考点是边界条件。M 和 N 的关系并不是 M < N 这种理想情况，题目会给 M 大于 N 的情况。循环右移的本质是每移动 N 次就回到原点，所以 M 对 N 取模的结果才是真正需要移动的有效次数。这一点如果没有先处理，代码要么超时，要么逻辑直接错乱。

第三个考点就是“输出格式”。PTA 对输出格式的要求出了名的严格，这道题也不例外：元素之间用空格隔开，最后一个元素后面不能有多余空格。很多同学算法全对，最后挂在多了一个空格上，真的是可惜。在考试或在线评测场景里，这种格式导致的“格式错误”或“答案错误”，往往比你想象中更容易发生。

1.2 考察的知识点清单

结合题目本身和常见题解，这题覆盖的知识点大致如下：

你会发现，这些知识点拆开看每一个都很基础，但组合在一起，对刚学完数组和循环的同学来说，思路不够清晰的话，写出来的代码会非常啰嗦，而且容易出 bug。

这种题目最典型的一个特点是：暴力解法和优化解法的代码量差异极大。有人的 AC 代码只有 15 行，有人写了 50 行还不停地报错。不是说代码越短越好，但代码短往往说明对题目本质理解得更清楚。

2. 从暴力解法说起：为什么一开始会超时或出错

很多人的第一版代码是这样的思路：既然要右移 M 次，那就用两层循环，外层循环跑 M 次，每次把最后一个元素临时存起来，然后从后往前把前面的元素依次往后挪一位，最后把临时存的元素放到数组开头。

逻辑上这个思路完全正确。模拟一下：数组是 [1, 2, 3, 4, 5]，N=5，M=1，先把 5 存到 temp，然后把 4 挪到第 5 个位置、3 挪到第 4 个位置、2 挪到第 3 个位置、1 挪到第 2 个位置，最后把 temp 里的 5 放到第 1 个位置。结果就是 [5, 1, 2, 3, 4]，正确。

问题出在性能上。

2.1 两层循环的真实成本

从后往前的这个内层循环，每次要移动 N-1 个元素。外层循环执行 M 次。总计移动次数是 M × (N-1)。如果题目给的 N 和 M 都只有 100 以内，这个复杂度完全没问题。但 N 和 M 的值如果到了 10^5 甚至 10^6 级别，移动次数就是 10^10 级别，超时几乎是必然的。

有同学会说，我提交的时候没超时啊，怎么回事？这是因为题目里如果 N 和 M 的范围给得比较小，暴力解确实能过。一旦 M 的值比 N 大很多，比如 M=10^9，哪怕 N=100，你也要跑 10^9 次循环，绝对超时。

所以暴力解法有一个必须的处理步骤：先让 M = M % N。既然右移 N 次等于没移动，那 M 次右移的有效次数就是 M 对 N 取模的结果。做了这一步之后，M 一定小于 N，两层循环的最坏移动次数是 N × (N-1)，如果 N 本身也不大，暴力解就能顺利通过。

2.2 暴力解法里最容易写错的细节

就算处理了取模，暴力解法仍有一个高频 bug：内层循环的移动方向写反。

右移和左移的覆盖方向是正好相反的。右移时，必须从数组末尾开始往前处理。如果你从前往后遍历，比如先把第 1 个元素赋给第 2 个位置，那第 2 个位置原本的值就被覆盖了，等你想把它赋给第 3 个位置的时候，拿到的已经是错的值。这个错误思路写出来代码非常自然，运行结果却会变成整体重复第一个元素。

我见过不少同学卡在这一步，对着代码看半天想不通。其实只要在纸上画一下数组下标的变化就明白了：

右移一位方向：arr[N-1] -> arr[N-2] -> ... -> arr[1] -> arr[0]

也就是从后往前遍历。如果写成 for (i = 0; i < N-1; i++) arr[i+1] = arr[i]，那就变成整体左移了，而且丢掉了开头元素。

2.3 时间复杂度和空间复杂度的初步判断

暴力解的时间复杂度是 O(N×M)（取模后最坏是 O(N^2)），空间复杂度 O(1)，因为它不需要额外开数组。对大多数题目场景来说，只要 N 的范围在 1000 以内，这个方案完全可接受，代码量也少。

不过它的问题在于：从算法设计的角度看，没有体现“循环”本质，属于模拟思维。如果你追求更高效的解，就要跳出“每次移动一个位置”的思维定式，直接从下标映射关系入手。

3. 换个思路：不移动数组也能“移动”

这是我个人觉得这道题最值得学习的地方。

题目要的是“输出右移后的结果”，它并没有规定你必须先把数组元素真的搬动一遍。如果允许偷懒，那最简单的方式就是：算出右移之后，新序列的第 1 个元素在原数组中的下标，然后从那个下标开始按顺序遍历输出。

这个过程我高一刷题时第一次见到，当时觉得非常惊艳：原来不是所有“序列变换”题都要真的做变换，有时候只需要改变“遍历的起点”。

3.1 下标映射的数学推导

假设原数组下标从 0 到 N-1。右移 M 位后，原来下标为 i 的元素会移动到下标 (i + M) % N 的位置。反过来问：右移之后，新的第 0 个元素，在原数组中的下标是多少？

右移 M 位后，原数组后 M 个元素被搬到了开头。所以新数组的第 0 个元素，就是原数组下标为 N-M 的元素。但要注意，这里 M 必须是取模后的有效值，也就是已经被处理成小于 N 的非负整数。如果你没取模，N-M 是负数，就直接越界报错了。

更稳妥的统一公式是：新序列第 i 个元素对应原数组下标 (N - M + i) % N。

拿 [1, 2, 3, 4, 5]，N=5，M=2 举例：右移 2 位后应该是 [4, 5, 1, 2, 3]。用公式算一下，新序列第 0 个元素对应原数组下标 (5-2+0)%5 = 3，原数组下标 3 的值为 4，正确。第 1 个元素对应 (5-2+1)%5 = 4，值为 5，正确。第 2 个对应 (5-2+2)%5 = 0，值为 1，正确。

这样遍历一遍数组就能得到右移后的完整序列，时间和空间都是 O(N) 和 O(1)。代码实现也特别简单：for 循环遍历 i 从 0 到 N-1，输出 arr[(N - M + i) % N] 即可。

3.2 输出逻辑与取模顺序的配合

使用这种思路时，输出逻辑必须和取模后的 M 保持一致。整个流程是：

1. 读取 N 和 M。
2. 读取 N 个数组元素。
3. M = M % N，得到真正需要右移的有效位数。
4. 从 i = 0 到 N-1 遍历，每次输出 arr[(N - M + i) % N]。

按这个顺序执行，无论 M 是 0、小于 N 还是大于 N，都能正确处理。M=0 时，(N - 0 + i) % N 正好等于 i，输出原数组顺序。M 是 N 的整数倍时，M%N=0，同样输出原序。M 大于 N 时，比如 N=5、M=7，取模后得到 2，等价于右移 2 位。

3.3 这种思路的适用边界

必须承认，这种“不移动只遍历”的思路并不是所有题目都能用。它只适用于题目只要求输出、不要求后续继续操作移动后数组的情况。如果题目说“右移后，再删除某个元素”或“右移后继续查询”，那你就必须真的把数组搬动好，否则后续操作全乱套。

所以做题的关键是先判断：题目到底只关心最终输出，还是关心移动后的数组状态。对于这道 B1008 来说，题目描述虽然用了“移动”这个词，但评分只看输出序列，因此这种“假移动”是安全的。

4. 标准的“三次反转法”是怎么来的

如果你不满足于只在输出层面偷懒，想学习真正操作数组实现右移的标准高效解法，那就要掌握“三次反转法”。

这个方法在数组旋转类问题里非常常用。LeetCode 的旋转数组、字符串的左旋右旋，全都能用同一套思路解决。学会了它，相当于掌握了一类题的通用工具。

4.1 从生活经验推导反转法

理解三次反转法有一个特别直观的生活类比：想象一组排队的学生，老师想让他们整体循环右移两位。一种做法是每个学生都同时站起来，往右挪两个位置，但这会造成大量位置冲突，必须有人先暂时出列。另一种做法是：先把整个队伍倒过来排，再分别把前后两段倒过来，最后队伍就变成了目标顺序。

具体到数组 [1, 2, 3, 4, 5]，右移 2 位。第一步，整个数组反转，得到 [5, 4, 3, 2, 1]。第二步，把前 M 个元素（也就是前 2 个）反转，得到 [4, 5, 3, 2, 1]。第三步，把剩余 N-M 个元素（后 3 个）反转，得到 [4, 5, 1, 2, 3]。结束。

整个过程只需要一个辅助变量就能完成元素交换，空间复杂度 O(1)，而每次反转的复杂度是线性的，整体也是 O(N)。

4.2 为什么反转三次能还原正确顺序

反转法的本质是：把一个数组分成前后两段。右移的本质是让后段跑到前段的前面。先整体反转，前后段的位置关系就反了，后段在前、前段在后。再各自反转一次，段内元素的相对顺序就恢复成原来的样子。两个操作组合起来，正好得到“后段原序 + 前段原序”的结果。

再用数学语言确认一遍：设数组 A 分为 X 和 Y 两段，右移后希望变成 Y + X。先整体反转得到 reverse(X+Y) = reverse(Y) + reverse(X)。再反转前段 reverse(Y) 得到 Y，反转后段 reverse(X) 得到 X。最终结果是 Y + X，目标达成。

这个过程我建议你一定要自己动手写一遍，找一个小数组在纸上推演。因为只靠眼睛看代码，很难真正建立“段内反转”这个操作的直觉。一旦推演过一次，以后再遇到类似的旋转题，你几乎不用思考就能写出来。

4.3 反转法的代码骨架

反转函数几乎是固定写法，核心就是双指针从两头往中间交换。要注意reverse的区间边界是左闭右开还是闭区间，不同的写法会影响调用时的传入参数。

以 C 语言为例，假设我们约定反转区间为 [left, right]，包含 left 和 right 本身，那么写出来是：

c复制void reverse(int arr[], int left, int right) {
    while (left < right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        left++;
        right--;
    }
}

调用时：

c复制reverse(arr, 0, N - 1);        // 整体反转
reverse(arr, 0, M - 1);        // 反转前 M 个
reverse(arr, M, N - 1);        // 反转后 N-M 个

写完后可以再把代码中 M、N-1 等边界代入测试一下，确认不会出现数组越界。

4.4 反转法和直接遍历法的对比

如果题目将来要复用数组，选反转法。如果只是应付这道题的 AC，下标映射法最快。暴力解法能过，但效率最差，不推荐作为主要方案。

5. 具体代码实现与完整注释

下面给出两种我自己实测能 AC 的写法，均用 C 语言。

5.1 方案一：下标映射直接遍历输出

c复制#include <stdio.h>

int main() {
    int n, m;
    scanf("%d %d", &n, &m);
    
    int arr[n];
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }
    
    // 关键：对 m 取模，去掉无效的整轮循环
    m = m % n;
    
    for (int i = 0; i < n; i++) {
        // 计算右移后第 i 个位置的元素来自原数组哪个下标
        int index = (n - m + i) % n;
        if (i > 0) {
            printf(" ");
        }
        printf("%d", arr[index]);
    }
    printf("\n");
    
    return 0;
}

这段代码的精髓就一行：int index = (n - m + i) % n。你只要理解这一行是怎么来的，整个代码就没有任何秘密了。

5.2 方案二：三次反转

c复制#include <stdio.h>

void reverse(int arr[], int left, int right) {
    while (left < right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        left++;
        right--;
    }
}

int main() {
    int n, m;
    scanf("%d %d", &n, &m);
    
    int arr[n];
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
    }
    
    m = m % n;
    
    // 注意：当 m 为 0 时，三段调用都不影响数组，仍然正确
    reverse(arr, 0, n - 1);
    reverse(arr, 0, m - 1);
    reverse(arr, m, n - 1);
    
    for (int i = 0; i < n; i++) {
        if (i > 0) {
            printf(" ");
        }
        printf("%d", arr[i]);
    }
    printf("\n");
    
    return 0;
}

这里有一个很隐蔽但很重要的细节：当 m = 0 时，第二行 reverse(arr, 0, -1)，left = 0，right = -1。循环条件 left < right 不成立，函数什么也不做，安全。第三行 reverse(arr, 0, n-1)，会把刚整体反转过的数组再反转回来，也安全。所以 m=0 时这段代码可以通过，不会因为数组越界而崩溃。

5.3 代码中值得注意的实现细节

几个高频出错的点我单独拎出来提一下：

第一，取模必须在反转之前完成。如果你忘了写 m = m % n，当 m > n 时，reverse 传入的 m 值会大于数组下标上限，reverse(arr, 0, m-1) 就会访问到数组越界区域，程序会直接崩溃或出现未定义行为。

第二，输出空格的判断建议使用“非首元素前加空格”策略。有同学喜欢在循环里直接给每个元素后面跟一个空格，再想办法删掉最后一个。这种思路可以实现，但处理起来很容易出错。相比之下，在输出前判断是否是第一个元素，如果是就直接输出数字，否则先输出一个空格再输出数字，是最稳妥的做法。

第三，读取数据时如果数组大小不确定，可以使用变长数组 int arr[n]，这在 C99 标准中是允许的。如果你的编译器不支持变长数组，就需要用动态内存分配或定义一个足够大的静态数组。PTA 的在线编译器通常支持 C99 变长数组，但保险起见，定义一个 int arr[1000] 或更大容量的数组也是常见的做法。

6. 常见报错与排查思路

刷题免不了碰壁，这里我按自己刷题经验和网上常见提问，把这道题最容易踩的坑列成一张速查表。碰到问题先对照这张表自查一遍，能省很多时间。

6.1 高频问题速查表

6.2 取模之前不取模，后果有多严重

我见过不少同学的代码，逻辑完全正确，就是忘了取模。当 M=1000000000、N=5 时，暴力解法外层循环会跑十亿次，程序直接超时。标程给出的时限通常非常紧，这种数据是专门用来卡暴力解法的。而使用下标映射或反转法的不取模版本，也会因为 m 值过大而直接越界。

所以任何时候，只要题目里出现了循环移动、循环左移、循环右移这类字眼，取模应该无条件成为你写代码的第一步。你甚至可以把它当成一个条件反射，看到题目就先把 M 处理掉。

6.3 一个隐藏的特殊情况：M 等于 0

题目如果不保证 M 非零，就需要处理 M=0 的情况。

用下标映射法时，m=0 直接得到 index = (n - 0 + i) % n = i，输出就是原数组，非常自然。用反转法时，只要保证 reverse 函数能正确处理空区间，也不会出问题。

问题只出在那些用动态内存或额外数组的同学身上：当 m=0 时，额外数组拷贝的逻辑如果写得不严谨，可能会出现空数组输出。这个检查一下自己的代码分支就能发现。

7. 这道题教给你的，不只是“右移”

大多数刷题的人都有一个通病：题目 AC 了就立刻做下一题，从来不复盘。但说实话，PTA B1008 这道题能在众多乙级题里被反复讨论，是因为它具备很好的“延展性”。

7.1 一套代码通吃多个变体

把这题的思路吃透，你会惊喜地发现，网上那些热搜词里的“字符串逆序”“单词翻转”等题目，本质上都在做同一类操作：反转数组、反转字符串、按边界反转局部片段。字符串逆序就是整体反转一次；单词翻转就是先整体反转句子，再把每个单词单独反转。计算思路和这题的三次反转法如出一辙。

我建议你把这道题的三种解法都实现一遍，然后自己给自己出几个变体题目练手，比如：

• 如果题目改成循环左移 M 位，下标映射公式怎么改？三次反转的段怎么切？
• 如果数组长度 N 非常大，但只要求输出右移后的前 K 个元素，怎么做最快？
• 如果要求在原数组上原地完成移动，且只能用 O(1) 额外空间，反转法如何保证不丢数据？

这三个问题分别对应了“公式迁移”“部分输出优化”和“原地算法约束”，都是常见面试或考试场景里的考点变形。能答上来，说明你是真学会了。

7.2 格式化输出：几乎所有 PTA 题目的隐形考点

最后想多说一句的是输出格式。

PTA 的判题很看重格式，Presentation Error（格式错误）和 Wrong Answer（答案错误）在分数上的差异不大，但在实际调试中特别消磨耐心。你需要养成一个习惯：每次写输出代码前，先思考“第一个元素怎么输出，中间怎么输出，最后一个怎么输出”，而不是写完循环再回来补空格。

这里再分享一个我在实际做题中发现的省心写法：用变量 flag 控制分隔符。

c复制int flag = 0;
for (int i = 0; i < n; i++) {
    if (flag) {
        printf(" ");
    }
    printf("%d", arr[i]);
    flag = 1;
}

这种写法比 if (i > 0) 稍微通用一点，尤其适合输出内容带有过滤条件时，比如要“输出所有满足条件的元素，中间用空格隔开”的场景。flag 一旦置 1 就始终保持，不用去判断当前是第几个有效输出，代码逻辑更清晰。

8. 再聊聊我踩过的几个坑

作为收尾，分享几个我个人在这道题上真实踩过、后来琢磨明白的坑，希望能帮你避免重复劳动。

第一个坑是迷信暴力解。我第一次做这道题时，N 和 M 的取值范围都没细看，上来就是两层循环嵌套，信誓旦旦提交，结果显示超时。后来仔细读了题目约束才发现 M 可以非常大。从那以后我养成了一个习惯：任何涉及移动步数的题，先取模再说。

第二个坑是写反转函数时区间边界混淆。我先把区间定义为左闭右开 [left, right)，写起来边界到处是 +1、-1，把一个简单函数写得漏洞百出。后来统一改成闭区间 [left, right]，参数传入直接用 0 和 n-1，思路立刻清晰了。区间表示没有绝对的优劣，但一定要统一，别在一个程序里混用两种约定。

第三个坑是处理空格输出时，想用“每个数字后面跟一个空格，最后用退格键删掉”。这个思路一看就不靠谱，但我还真见过有人这么写。在终端里退格符也许有效，在在线评测系统里，结果文件里不会真的执行退格操作，基本就是白费力气。老老实实用“非首元素前加空格”或者 flag 法，别在格式上耍小聪明。

回到开头那句话：这是一道基础题，但基础的题里藏着的细节一点都不基础。搞懂它，你后面会遇到的大量数组和字符串操作题，都会顺很多。写这篇文章也算是给自己刷题过程留个记录，希望对正在刷 PTA 的你有一点帮助。