火车车厢重排问题,队列,c语言

合集下载

火车车厢重排问题,队列,c语言

计算机科学与工程学院
《算法与数据结构》试验报告[一]
专业班级10级计算机工程02 试验地点计算机大楼计工教研室学生学号1005080222 指导教师蔡琼
学生姓名肖宇博试验时间2012-4-21
试验项目算法与数据结构
试验类别基础性（）设计性（）综合性（√）其它（）试
验目的及要求（1）掌握队列的特点及其存储方法；（2）掌握队列的常见算法和程序实现。

成绩评定表
类别评分标准分值得分合计
上机表现积极出勤、遵守纪律
主动完成设计任务
30分
程序与报告程序代码规范、功能正确
报告详实完整、体现收获
70分
goto label2;
}
else if(r!=0)
{
printf("重排前的序列为\n");
for(i=1;i<=k;i++)
{
printf("%d\t",a[i]);
}
printf("\n");
printf("排列后的车厢号为：\n");
reset(q,w1,w2,k);
}
else
{
printf("我也不知道错哪了？'");
}
}
四、测试用例（尽量覆盖所有分支）
1.输入正确的序列后得到结果如图：
2.倒输这几个数如图：
3.顺序输这个序列
4.如果输入的车厢数有误的时候（为负数或零）
5.如果输入的序列不是连续自然数。

火车重排问题

火车车厢重排问题1.1火车车厢重排问题一列货运列车共有n节车厢，每节车厢将停放在不同的车站。

假定n个车站的编号分别为1~n,货运列车按照第n站至第1站的顺序经过这些车站。

车厢编号与他们的目的地一样。

为了便于从列车上卸掉相应的车厢，必须重排车厢顺序，使得各车厢从前往后按编号1到n的次序排列。

当所有车厢按照这种次序排列时，在每个车站只需卸掉最后一个车厢即可。

1.2想法一列火车的每个车厢按顺序从入轨进入不同缓冲轨，缓冲轨重排后的进入出轨，重新编排成一列货车。

比如：编号为3的车厢进入缓冲轨1，则下一个编号小于3的车厢则必须进入下一个缓冲轨2，而编号大于3的车厢则进入缓冲轨1，排在3号车厢的后面，这样，出轨的时候才可以按照从小到大的顺序重新编排我们在一个转轨站里完成重拍的工作，在转轨站有一个入轨，一个出轨和k个缓冲轨（位于入轨和出轨之间）。

下面的图示就是一个转轨站，其中有3个缓冲轨，H1,H2,H3。

（PPT中有动态演示）1.3算法描述：那么缓冲轨就不是FILO 而是FIFO了那么就要用队列来实现车厢重排了，算法的描述和栈实现的基本一样的，只是OutPut和Hold 函数改了一下，将一截车厢移动到缓冲轨时，车厢c应该移动到这样的缓冲轨中：该缓冲轨中现有各车厢的编号均小于c，如果有多个缓冲轨都满足这一条件，那么选择其中左端车厢编号最大的那个缓冲轨，否则选择一个空的缓冲轨(如果存在的话)1.4代码：#include<iostream>#include<stack>usingnamespace std;template<class T>void PrintfNum(T a[], constint& n);// move cars from holding track to output trackvoid OutPut(stack<int> t[],int n, int totalStack,int& min){//move car from holding trackfor(int x = 0;x <totalStack; ++x){if(!t[x].empty() && t[x].top() == min){cout<<"Move car "<< t[x].top() <<" from holding track "<< x <<" to output"<<endl;t[x].pop();++min;x = -1; // find next car from the first holding track 0}}}// move cars from input track to holding trackbool Hold(stack<int> t[],int n , int totalStack){for(int i = 0;i <totalStack; ++i){if(t[i].empty() || (!t[i].empty() && t[i].top() > n)){cout<<"holding track "<<i<<" hold car "<< n <<endl;t[i].push(n);returntrue; // we already find a holding track, so break the loop. }}returnfalse;}int main(int argc, char* argv[]){constint NUM = 9;constint STACKNUM = 3;stack<int> t[STACKNUM];int min = 1;int a[NUM] = {5,8,1,7,4,2,9,6,3};PrintfNum(a,NUM);for(int i = NUM - 1; i>= 0; --i){if(a[i] == min){// try to move cars from input track or holding track cout<<"Move car "<< a[i] <<" from input to output"<<endl;++min;OutPut(t,a[i],STACKNUM,min);}else{// move cars from input track to holding trackif(!Hold(t,a[i],STACKNUM)){cout<<"Not enough holding track"<<endl;break;}}} getchar();return 0;}template<class T>void PrintfNum(T a[], constint& n){for(int i = 0; i< n; ++i){cout<< a[i] <<",";}cout<<endl;}1.5火车车厢重排问题决策过程H1H2H31.5.1初始数组H1 H2 H31.5.2H1H2H3H1 H2 H3H1 H2 H3H1 H2 H3H1 H2 H3H1 H2 H3H1H2 H3H1 H2 H3H1 H2 H3H1 H2 H3H1 H2 H3 1．6程序运行截图。

实验2用堆栈解决火车车厢重排问题的编程

实验2用堆栈解决火车车厢重排问题的编程一、目的通过对本次实验，我们应：1、加深对线性表、堆栈的认识；2、加深接口、类、索引器的认识；3、掌握堆栈数据结构，并应用堆栈编程解决实际问题。

二、实验准备1、软件准备：C#.net。

2、参考数据（示例）：文件夹“…\实验2\示例”中的数据。

三、实验背景描述1、问题描述一列货运列车共有n节车厢，每节车厢将停放在不同的车站。

假定n个车站的编号分别为1 -n，货运列车按照第n站至第1站的次序经过这些车站。

车厢的编号与它们的目的地相同。

为了便于从列车上卸掉相应的车厢，必须重新排列车厢，使各车厢从前至后按编号1到n的次序排列。

当所有的车厢都按照这种次序排列时，在每个车站只需卸掉最后一节车厢即可。

我们在一个转轨站里完成车厢的重排工作，在转轨站中有一个入轨、一个出轨和k个缓冲铁轨（位于入轨和出轨之间）。

图3.1a 给出了一个转轨站，其中有k= 3个缓冲铁轨H1，H2和H3。

开始时，n节车厢的货车从入轨处进入转轨站，转轨结束时各车厢从右到左按照编号1至编号n的次序离开转轨站（通过出轨处）。

在图3.1a 中，n= 9，车厢从后至前的初始次序为5，8，1，7，4，2，9，6，3。

图3.1b 给出了按所要求的次序重新排列后的结果。

图2.1根据上面的描述，编写程序实现下面的功能：编写一算法实现火车车箱的重排；编写程序模拟图2.1所示的具有9节车厢的火车入轨和出轨的过程。

程序主界面设计如图2.2所示。

图2.22、问题分析为了重排车厢，需从前至后依次检查入轨上的所有车厢。

如果正在检查的车厢就是下一个满足排列要求的车厢，可以直接把它放到出轨上去。

如果不是，则把它移动到缓冲铁轨上，直到按输出次序要求轮到它时才将它放到出轨上。

缓冲铁轨上车厢的进和出只能在缓冲铁轨的尾部进行。

当缓冲铁轨上的车厢编号不是按照从顶到底的递增次序排列时，重排任务将无法完成。

新的车厢u应送入这样的缓冲铁轨：其底部的车厢编号v满足v>u,且v是所有满足这种条件的缓冲铁轨顶部车厢编号中最小的一个编号。

火车车厢重排问题栈c语言

火车车厢重排问题栈c语言以下是一个用C语言实现火车车厢重排问题的代码：```c#include <stdio.h>#include <stdlib.h>#define MAX_SIZE 100typedef struct {int val;struct Node* next;} Node;typedef struct {Node* top;} Stack;Stack* createStack() {Stack* stack = (Stack*)malloc(sizeof(Stack));stack->top = NULL;return stack;}int isEmpty(Stack* stack) {return (stack->top == NULL);}void push(Stack* stack, int val) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->val = val;newNode->next = stack->top;stack->top = newNode;}int pop(Stack* stack) {if (isEmpty(stack)) {printf("Stack is empty.\n");return -1;}int val = stack->top->val;Node* temp = stack->top;stack->top = stack->top->next;free(temp);return val;}int peek(Stack* stack) {if (isEmpty(stack)) {printf("Stack is empty.\n");return -1;}return stack->top->val;}int canReorder(int numCars, int cars[]) { Stack* stationStack = createStack(); Stack* branchStack = createStack(); int nextCar = 1;for (int i = 0; i < numCars; i++) {// 如果当前车厢和需要出站的车厢一致，直接出站if (cars[i] == nextCar) {nextCar++;continue;}// 将从站台出来的车厢压入分支轨道while (!isEmpty(stationStack) && peek(stationStack) == nextCar) {push(branchStack, pop(stationStack));nextCar++;}// 当前车厢进站push(stationStack, cars[i]);}// 如果分支轨道中的车厢可以按顺序出站，则返回1，否则返回0while (!isEmpty(branchStack)) {if (pop(branchStack) != nextCar) {return 0;}nextCar++;}return 1;}int main() {int numCars;int cars[MAX_SIZE];printf("Enter the number of train cars: ");scanf("%d", &numCars);printf("Enter the train car numbers: ");for (int i = 0; i < numCars; i++) {scanf("%d", &cars[i]);}int result = canReorder(numCars, cars);if (result) {printf("Yes, it is possible to reorder the train cars.\n"); } else {printf("No, it is not possible to reorder the train cars.\n"); }return 0;}```输入示例：```Enter the number of train cars: 5Enter the train car numbers: 3 1 2 4 5```输出示例：```Yes, it is possible to reorder the train cars. ```。

《数据结构c语言》车厢调度问题解析（经典递归）

车厢调度问题解析（经典递归）博客分类：zhanghonglun算法算法题目假设停在铁路调度站入口处的车厢系列的编号依次为1，2，3，…n。

设计一个程序,求出所有可能由此输出的长度为n 的车厢系列。

解析:一个数的进栈以后,有两种处理方式：要么立刻出栈，或者下一个数的进栈(如果还有下一个元素)其出栈以后，也有两种处理方式：要么继续出栈（栈不为空），或者下一个数的入栈。

该问题有天然的递归性质算法设计:两重递归，下一个元素处理完后返回，再处理出栈的递归,有点像嵌套循环，但比它复杂...进栈的递归跳出条件为最后一个元素进栈出栈的递归跳出条件为栈空附上经典实现代码C代码1.#include<stdafx.h>2.#include<stdio.h>3.#define MaxLen 1004.struct snode{5. int data[MaxLen];6. int top;7.}s;//定义一个栈指针8.int n;//定义输入序列总个数9.void Initstack()10.{11. s.top=-1;12.}13.void push(int q)//元素n进栈14.{15. s.top++;16. s.data[s.top]=q;17.}18.int pop()//出栈19.{20. int temp;21. temp=s.data[s.top];22. s.top--;23. return temp;24.}25.int Emptys()//判断栈空26.{27. if(s.top==-1)28. return 1;29. else30. return 0;31.}32./*33.每次调用求值阶段包含两重递归，只有全部返回，才表示本pos 处理完，可以对上一个元素求值，process 就是找出当前元素进栈后所有可能的操作，即在当前元素进栈后各种情况下，34.包括不出栈，立即出栈，出栈后继续出栈情况(出栈递归)下，继续处理下一个元素(入栈递归)35.36.*/37.void process(int pos,int path[],int curp)//当前处理位置pos的元素38.{39. int m,i;40. if(pos<n)//编号进栈递归41. {42. push(pos+1);//当前元素进栈后下一个元素继续进栈43. process(pos+1,path,curp); //处理下一个元素，返回表明下一个元素进栈的情况处理完了44. pop(); //下一个元素处理完后，pop 掉，准备处理直接出栈45. }46.47. if(!Emptys())//递归处理出栈48. {49. m=pop();50. path[curp]=m;51. curp++;52. process(pos,path,curp);//出栈后处理下一个素继续进栈53. push(m);54. }55. if(pos==n&&Emptys())//输出一种可能的方案56. {57. for(i=0;i<curp;i++)58. printf("%2d",path[i]);59. printf("\n");60. }61.}62.void main()63.{64. int path[MaxLen];65. printf("输入要调度车厢总数:");66. scanf("%d",&n);67. Initstack();68. push(1);69. printf("所有输出序列:\n");70. process(1,path,0); //从1 开始，递归处理所有元素71.}。

列车排序

一、实验目的队列的应用二、实验内容利用队列结构实现车厢重排问题。

三、算法描述利用一个队列组中的多个队列充当缓冲轨，根据需要动态对其分配空间。

进入缓冲轨前，要求与已有的缓冲轨的队尾元素进行比较，当队尾元素小时入队，否则进入一个新的缓冲轨；当入轨为空时，进行出队操作，每次出队之前，比较每个缓冲轨队头元素的值大小，小的先出队。

四、算法实现int EnQueue(LinkQueue &Q,int e)//排列{QueuePtr p=(QueuePtr)malloc(sizeof(QNode));if(!p)exit(0);p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;return 1;}int DeQueue(LinkQueue &Q,int &e){QueuePtr p;if(Q.front==Q.rear)return(0);p=Q.front->next;e=p->data;Q.front->next=p->next;if(Q.rear==p)Q.rear=Q.front;free(p);return 1;}int RanQueue(LinkQueue &Q,LinkQueue &D,int n){int p=0,q=0,i=0,j=0,k=0;LinkQueue T[10];InitQueue(T[0]);DeQueue(Q,p);EnQueue(T[0],p);loop1: while(Q.front!=Q.rear){DeQueue(Q,p);for(i=0;i<=j;i++){if(p>T[i].rear->data){EnQueue(T[i],p);goto loop1;}}j++;InitQueue(T[j]);EnQueue(T[j],p);}do{for(i=0;i<=j;i++){if(T[i].front!=T[i].rear){p=T[i].front->next->data;q=i;}}for(i=0;i<=j;i++){if(T[i].front!=T[i].rear&&p>T[i].front->next->data){p=T[i].front->next->data;q=i;}}DeQueue(T[q],p);EnQueue(D,p);k++;}while(k!=n);return 1;}五、实验结果五、心得体会为达到动态创建队列的目的，使用队列数组，根据需要动态对其分配空间，但是还是受到定义数组初始队列数的限制，当列车节数足够大时依然会导致内存空间不足。

火车车厢重排问题栈c语言

火车车厢重排问题栈c语言火车车厢重排问题是一个经典的问题，考验了数据结构和算法的运用。

这个问题可以很好地帮助我们了解如何使用栈这种数据结构来解决实际问题，并且可以通过编写C语言程序对其进行求解。

在本文中，我们将深入探讨火车车厢重排问题，并编写C语言程序实现问题的求解。

首先，让我们来了解一下火车车厢重排问题的具体描述。

假设有一列火车车厢按照编号从1到n的顺序排列在轨道上。

现在我们需要将这些车厢按照特定的顺序重新排列，给定一个目标排列，我们需要找出一种排列车厢的方法，使得最终的排列符合目标排列。

具体而言，对于每一个车厢，我们可以将其从原来的位置移动到一个临时的缓冲轨道中，然后再将其移动到目标位置。

这个问题的关键在于如何确定每个车厢应该如何移动才能满足最终的目标排列。

为了解决这个问题，我们可以使用栈这种数据结构来辅助实现。

栈是一种先进后出的数据结构，这样的特性非常适合用来模拟火车车厢的重排过程。

具体而言，我们可以将原始轨道上的车厢编号序列作为输入，然后使用栈来模拟车辆的移动过程，最终得到目标排列。

下面我们将通过C语言程序来实现这个过程。

首先，我们需要定义一个栈的数据结构，来模拟车厢的移动过程。

我们可以使用数组来实现这个栈，同时需要定义一个栈顶指针来表示当前栈顶元素的位置。

另外，我们还需要定义一个函数来模拟入栈和出栈的过程。

接下来，让我们来具体实现这个栈的数据结构和相关的函数。

```c#include <stdio.h>#include <stdlib.h>#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int top;} Stack;void init(Stack *s) {s->top = -1;}void push(Stack *s, int value) { if (s->top < MAX_SIZE - 1) {s->top++;s->data[s->top] = value;} else {printf("Stack overflow\n");}}int pop(Stack *s) {if (s->top >= 0) {int value = s->data[s->top];s->top--;return value;} else {printf("Stack underflow\n"); return -1;}}int main() {Stack s;init(&s);//对栈进行入栈和出栈操作push(&s, 1);push(&s, 2);push(&s, 3);printf("%d\n", pop(&s)); //输出3printf("%d\n", pop(&s)); //输出2printf("%d\n", pop(&s)); //输出1printf("%d\n", pop(&s)); //输出Stack underflow，表示栈已空return 0;}```在这段代码中，我们定义了一个栈的数据结构，并实现了栈的初始化、入栈和出栈操作。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

3.顺序输这个序列
4.如果输入的车厢数有误的时候（为负数或零）
5.如果输入的序列不是连续自然数
五、实验总结
先后学习了 C/C++,对编程语言基本上有一些了解，但在数据结构试验程序设计过程中还是学到了很多。
经过两天的设计，在不断翻阅以前资料的情况下，有针对性的复习了 C/C++ 中指针、循环的相关理论知识和的基础知识和应用技巧，最后比较成功的完成了本次的设计。这次的实验是完成火车厢重徘问题，依旧采用的检查用户的错误输入机制，充分考虑了用户的各种错误，比如输入的序列不是连续自然数，如果输入的车厢数有误的时候（为负数或零）等等的情况，完成了该次实验，主要出现的问题在于数组的下标问题，老是出现越界访问错误等等，这要在下次的实验当中多加注意！
return q->data[q->front+1]; }
int getrear(squeue *&q) {
{ return q->data[q->rear];
} }
void reset(squeue *&q,squeue *&w1,squeue *&w2,int k) {
int nowout=1; int n1=0,n2=0; for(int i=0;i<50;i++) {
出轨
H1
1
入轨
H3
出轨
H2 (d) 将 6789 移至出轨
火车车厢重排算法伪代码如下：
1. 分别对k个队列初始化； 2. 初始化下一个要输出的车厢编号nowOut = 1; 3. 依次取入轨中的每一个车厢的编号；
如果入轨中的车厢编号等于nowOut，则输出该车厢； nowOut++；
否则，考察每一个缓冲轨队列 for (j=1; j<=k; j++) 取队列 j 的队头元素c；如果c=nowOut，则将队列 j 的队头元素出队并输出； nowOut++；
类别上机表现程序与报告
成绩评定表
评分标准
分值得分
积极出勤、遵守纪律主动完成设计任务
30 分
程序代码规范、功能正确报告详实完整、体现收获
70 分
合计
备注：
评阅教师：日期：
年月日
试验内容
一、实验目的和要求
1、实验目的：（1）掌握队列的特点及其存储方法；（2）掌握队列的常见算法和程序实现。
}
else if(gettop(w2)==nowout) {
printf("%d 号车厢出轨！\t",gettop(w2)); nowout++; dequeue(w2);
} else {
int c=gettop(q); n1=getrear(w1); n2=getrear(w2); if(n1>n2) {
计算机科学与工程学院
《算法与数据结构》试验报告[一]
专业班级学生学号学生姓名
10 级计算机工程 02 22
肖宇博
试验地点指导教师试验时间
计算机大楼计工教研室蔡琼
2012-4-21
试验项目
试验类别
试验目的及要求
算法与数据结构基础性（）设计性（）综合性（√）其它（）
（1）掌握队列的特点及其存储方法；（2）掌握队列的常见算法和程序实现。
if(c>n1) {
enqueue(w1,c); dequeue(q); } else { enqueue(w2,c); dequeue(q);
} } else {
if(c>n2) e { enqueue(w1,c); dequeue(q);
3、实验要求如：果入轨和缓冲轨的队头元素没有编号为nowOut的车厢，则使用求顺小序于入存轨储中队第一列个的车方厢编式号完的成最大该队实尾验元素。所在队列编号j;
二、设计分析如果 j 存在，则把入轨中的第一个车厢移至缓冲轨 j；
根据实验要如求果，j采不用存在队，列但来有多完于成一本个空次缓实冲验轨，。则把入轨中的第一个车厢移至一个空缓实验中定义了三冲轨个；队否列则车，厢一无个法用重排来，存算储法结输束入；的车厢号，另两个用来存储缓存出队顺序及序号。
void enqueue(squeue *&q,int e) {
q->rear=(q->rear+1)%Max; q->data[q->rear]=e; }
void dequeue(squeue *&q) {
q->front=(q->front+1)%Max; }
int gettop(squeue *&q) {
2、实验内容: 火车车厢重排问题。
转轨站示意图如下：
H1
3
H3
入轨
H2
1
出轨
963 H1
581
入轨
H3
742
出轨
H2 (a) 将 369、247 依次入缓冲轨
96
H1
5
54321
入轨
H3
87
出轨
H2 (c) 将 8 入缓冲轨，5 移至出轨
96
H1
58
4321
入轨
H3
7
出轨
H2
(b) 将 1 移至出轨，234 移至
if(q->data[q->front+1]==nowout) {
printf("%d 号车厢出轨！\t",q->data[q->front+1]); nowout++; dequeue(q); } else if(gettop(w1)==nowout) {
printf("%d 号车厢出轨！\t",gettop(w1)); nowout++; dequeue(w1);
printf("请输入正确的车厢号!\n");
printf("****************************************************"); printf("\n"); goto label;
} label2: printf("输入重排前的序列\n"); for(int i=1;i<=k;i++) {
printf("%d\t",a[i]); } printf("\n"); printf("排列后的车厢号为：\n"); reset(q,w1,w2,k); } else { printf("我也不知道错哪了？'"); } }
四、测试用例（尽量覆盖所有分支）
1.输入正确的序列后得到结果如图：
2.倒输这几个数如图：
三、源程序代码
#include<> #include<>
#define Max 20 typedef struct
{ int data[Max]; int front,rear;
}squeue;
void initqueue(squeue *&q) {
q=(squeue *)malloc(sizeof(squeue)); q->front=q->rear=0; }
scanf("%d",&a[i]); enqueue(q,a[i]); } int r=examenter(a,k);
if(r==0) {
printf("您的输入车厢号有误! 请输入连续自然数:\n"); goto label2; } else if(r!=0) { printf("重排前的序列为\n"); for(i=1;i<=k;i++) {
}
} }
} }
int examenter(int a[],int k) {
for(int i=1;i<=k;i++) {
if(a[i]!=i) {
return 0; break; }
} }
void main() {
squeue *q,*w1,*w2; initqueue(q); initqueue(w1); initqueue(w2); int a[10],k; label: printf("要输入几个车厢？\n"); scanf("%d",&k); if(k<=0) {

火车车厢重排问题,队列,c语言