实用指南：[数据结构] 队列实战！火车车厢重排从 0 到 1：缓冲轨巧用 + 可运行代码

队列实战！火车车厢重排从0到1：缓冲轨巧用+可运行代码（附测试验证）

刚做队列应用实验时，我对着火车车厢重排的示意图卡了好久：入轨、缓冲轨、出轨三个队列到底怎么配合？明明车厢编号是1~9的连续数，却不知道什么时候该把车厢暂存到缓冲轨，什么时候该输出到出轨，连“3692471850”这个测试用例都跑不出123456789的结果。后来才发现，核心就是利用队列“先进先出”的特性，让缓冲轨当“临时仓库”，每一步都盯着“下一个要出的编号”（nowOut）来运行。

今天就把这份《算法与数据结构》的解题思路拆成“新手友好版”，从转轨站结构讲到代码落地，再到实测验证，全程大白话+可复制代码，确保你跟着做就能跑通车厢重排。

一、实验核心：要解除啥问题？转轨站咋工作？

实验题目：火车车厢重排。实验说明：转轨站示意图如下：

火车车厢重排过程如下：

火车车厢重排算法伪代码如下：

1. 实验目标

给定一组连续编号（1~n）但顺序打乱的火车车厢（比如3、6、9、2、4、7、1、8、5），用队列模拟“转轨站”，把车厢重排成1、2、3…n的顺序，最终从“出轨”输出。

2. 转轨站结构（关键！先看懂再写代码）

实验里的转轨站有3类队列，作用各不相同，对应代码里的H1、H2、H3：

队列类型	代码中的队列	作用
入轨	H3	存放刚开始打乱的车厢序列（比如输入的369247185）
缓冲轨	H1、H2	暂存暂时不能输出到出轨的车厢，必须保证车厢编号大于队尾（比如H1队尾是2，只能放3、4…，后续才能有序出队）
出轨	无单独队列	最终输出有序车厢的“通道”，输出一个，下一个要输出的编号（nowOut）就+1

二、核心解题思路（3步走，大白话版）

整个重排逻辑围绕“下一个要输出的编号（nowOut）”展开，nowOut初始为1（第一个要输出的是1），然后循环处理直到所有队列都空：

步骤1：初始化准备

• 初始化3个队列：H1（缓冲轨1）、H2（缓冲轨2）、H3（入轨）；
• 把用户输入的打乱车厢（以0结束）依次放入H3；
• 定义nowOut = 1，记录下一个要输出到出轨的车厢编号。

步骤2：循环处理车厢（核心逻辑）

遍历H3（入轨），每一步做3件事：

1. 判断入轨队头能不能直接出：如果H3的队头编号 == nowOut，直接输出到出轨，nowOut+1（比如nowOut=1时，H3队头是1就输出，nowOut变2）；
2. 判断缓冲轨队头能不能出：若是H1或H2的队头 == nowOut，输出该车厢，nowOut+1（比如nowOut=2时，H2队头是2就输出）；
3. 入轨车厢放进缓冲轨：假设前两步都不能出，就把H3的队头放进H1或H2——要求是“车厢编号 > 缓冲轨队尾”（空缓冲轨可以直接放），保证后续能有序出队（比如H1队尾是3，只能放4、5…）。

步骤3：直到所有队列空

重复步骤2，直到H3（入轨）、H1（缓冲轨1）、H2（缓冲轨2）都为空，此时出轨已经输出1、2、3…n的有序序列。

三、完整代码实现（补全原文错误，附详细注释）

原文代码有小问题（比如队列初始化没设front、return θ笔误），这里已修正，新手可直接复制运行：

#include <stdio.h>#define MAXSIZE 100  // 队列最大容量，足够应对实验需求typedef int SElemType;  // 车厢编号类型（整数）typedef int Status;     // 函数返回状态（0=失败，1=成功）// 队列结构体（顺序队列）typedef struct Queue {SElemType data[MAXSIZE];  // 存车厢编号int front;               // 队头指针（出队从front）int rear;                // 队尾指针（入队从rear）} Queue;// 1. 初始化队列（front和rear都设0，代表空队列）void InitQueue(Queue *q) {q->front = 0;    // 原文漏了front初始化，必须加上！q->rear = 0;// data[0]初始化没必要，队列用front和rear控制，不是靠data[0]}// 2. 入队（把编号num放进队列q）Status EnQueue(Queue *q, SElemType num) {// 队列满的判断：rear到最大容量-1（留一个位置防溢出，也可设为rear >= MAXSIZE）if (q->rear >= MAXSIZE - 1) {printf("队列满了，无法入队！\n");return 0;  // 原文是θ，修正为0}q->data[q->rear] = num;  // 队尾放元素q->rear++;               // 队尾后移return 1;}// 3. 出队（把队列q的队头元素存到num，成功返回1）Status DeQueue(Queue *q, SElemType* num) {// 队列空的判断：front == rearif (q->front >= q->rear) {// printf("队列空了，无法出队！\n");return 0;}*num = q->data[q->front];  // 取队头元素q->front++;                // 队头后移return 1;}// 4. 取队头元素（只看，不出队，存到num）Status GetHead(Queue *q, SElemType* num) {if (q->front >= q->rear) {return 0;}*num = q->data[q->front];return 1;}// 5. 取队尾元素（只看，不出队，存到num）Status GetRear(Queue *q, SElemType* num) {if (q->front >= q->rear) {return 0;}*num = q->data[q->rear - 1];  // 队尾是rear-1（因为rear指向空位置）return 1;}// 主函数：火车车厢重排逻辑int main() {Queue H1, H2, H3;  // H1=缓冲轨1，H2=缓冲轨2，H3=入轨InitQueue(&H1);InitQueue(&H2);InitQueue(&H3);Queue* bufferQueues[] = {&H1, &H2};  // 缓冲轨数组，方便循环遍历// 1. 输入打乱的车厢编号（输入0停止）printf("请输入火车车厢编号（连续整数，输入0停止）：\n");SElemType inputNum;while (1) {scanf("%d", &inputNum);if (inputNum == 0) {break;  // 输入0结束}EnQueue(&H3, inputNum);  // 放入入轨H3}// 2. 初始化下一个要输出的车厢编号（从1开始）int nowOut = 1;printf("\n出轨输出序列：");// 循环处理：入轨、缓冲轨都为空才结束while (H3.front < H3.rear || H1.front < H1.rear || H2.front < H2.rear) {int isOutput = 0;  // 标记本次是否有车厢输出到出轨SElemType tempNum;  // 临时存车厢编号// 步骤1：判断入轨H3的队头能不能直接输出if (GetHead(&H3, &tempNum) && tempNum == nowOut) {DeQueue(&H3, &tempNum);  // 出队printf("%d ", tempNum);   // 输出到出轨nowOut++;                 // 下一个要输出的编号+1isOutput = 1;}// 步骤2：如果入轨不能出，看缓冲轨（H1、H2）的队头能不能出else {for (int i = 0; i < 2; i++) {  // 遍历两个缓冲轨if (GetHead(bufferQueues[i], &tempNum) && tempNum == nowOut) {DeQueue(bufferQueues[i], &tempNum);printf("%d ", tempNum);nowOut++;isOutput = 1;break;  // 输出一个即可，下一轮再判断其他}}}// 步骤3：如果都不能出，把入轨H3的队头放进合适的缓冲轨if (!isOutput) {GetHead(&H3, &tempNum);  // 取入轨当前要处理的车厢SElemType bufferRear;    // 缓冲轨的队尾编号// 遍历缓冲轨，找能放的（空缓冲轨 或 车厢编号>缓冲轨队尾）for (int i = 0; i < 2; i++) {if (bufferQueues[i]->front == bufferQueues[i]->rear) {  // 缓冲轨空DeQueue(&H3, &tempNum);EnQueue(bufferQueues[i], tempNum);break;} else {  // 缓冲轨非空，判断是否大于队尾GetRear(bufferQueues[i], &bufferRear);if (tempNum > bufferRear) {DeQueue(&H3, &tempNum);EnQueue(bufferQueues[i], tempNum);break;}}}}}printf("\n车厢重排完成！\n");return 0;}

四、运行测试：实测验证（和实验结果一致）

测试用例：输入3 6 9 2 4 7 1 8 5 0（输入0停止）

• 输入过程：运行程序后，依次输入3 6 9 2 4 7 1 8 5 0，按回车；

• 输出结果：出轨输出序列：1 2 3 4 5 6 7 8 9 车厢重排完成！；
  

• 验证：完全符合“1~9有序”的要求，实验测试用例3692471850（即输入3 6 9 2 4 7 1 8 5 0）运行正确。

五、新手避坑指南（我踩过的坑，你别踩）

1. 缓冲轨放车厢必须“大于队尾”
   比如H1队尾是2，不能放1！否则1永远在2后面，当nowOut=1时，H1队头是2，1出不来，最后重排失败。这是实验的核心规则，必须遵守。

2. 队列初始化要设front=0
   原文代码的InitQueue只设了rear=0，漏了front=0，导致队列判断空/满出错，必须补上q->front=0。

3. nowOut要及时自增
   每次输出一个车厢后，一定要nowOut++，否则会一直重复输出同一个编号（比如一直找1，找到后不+1，下次还找1）。

4. 入轨遍历要“先判后出”
   处理入轨车厢时，先通过GetHead判断能不能出，再用DeQueue出队，不能直接DeQueue后再判断，否则会把不该出的车厢删掉。

六、总结：队列的核心价值&优化方向

1. 队列在实验中的作用

• 入轨（H3）：“先进先出”保证打乱的车厢按输入顺序处理；
• 缓冲轨（H1、H2）：“暂存+有序”，通过“车厢>队尾”的规则，确保后续能按1、2、3…的顺序出队；
• 出轨：“顺序输出”，最终得到有序序列。

2. 时间复杂度说明

原文提到“时间复杂度较高”，主要是因为每次处理都要遍历缓冲轨（H1、H2），最坏情况下时间复杂度是O(n*k)（n是车厢数，k是缓冲轨数）。优化方向可以是“记录缓冲轨队尾最大值”，不用每次遍历找合适的缓冲轨，减少循环次数。