火车车厢重排问题,队列,c语言
数据结构课程标准
1 课程标准1.1 课程定位《数据结构》是计算机类专业的核心课程之一，是软件技术专业必修的专业基础课程，也是其它非计算机专业的主要选修课程之一。
数据结构研究的范围和计算机软件有着密切的关系，无论是编译源程序还是操作系统，都涉及到数据元素在存储器中如何分配的问题。
在研究信息检索时也必须考虑如何组织这些数据，以便使查找和存取数据元素更为高效。
因此，可以认为数据结构是介于数学、计算机硬件和计算机软件三者之间的一门核心课程，在计算机科学中，数据结构不仅是一般程序设计（特别是非数值计算的程序设计）的基础，而且是设计和实现编译程序、操作系统、数据系统及其它系统程序和大型应用程序的重要基础。
由于《数据结构》是一门理论性很强的课程，重在理论，而高职教学的主要目标是培养高级技术应用型人才，更加偏重于实践能力的培养，所以我们针对高职学生的特点，在教学过程中对《数据结构》课程进行了系列教学改革，并取得了较好的效果。
本课程以就业为导向，从高技能人才培养的要求出发，以强化技术应用能力培养为主线，构建理论教学体系和实践教学体系。
在教学内容上，按照理论知识够用的高职教育原则，根据学生知识能力、企业岗位能力要求等，弱化了无应用性或应用性不强的内容，强化了工程项目中常用的知识点，构建了必须的教学单元。
1.2 工作任务和课程目标1.2.1 工作任务及职业能力表1-1 工作任务与职业能力分析表1.2.2 课程目标本课程的主要目标是使学生深入了解数据结构的逻辑思想、实现方法和应用技术。
本课程追求理论联系实际，教学与实践相呼应。
灵活多样地采取了编程、拓展性学习、案例教学、讨论、报告，大型作业，科研项目等多种形式，激发学生的学习兴趣和主动参与精神，使学生理解原理，掌握方法，熟练应用，能够创造性地应用各种数据结构和算法设计性能优，效率高，可读性强，易维护的程序，解决实际问题，提高学生的学习能力，探索研究的能力。
根据课程面对的工作任务和职业能力要求，本课程的教学目标为：（1）知识目标1）数据结构的基本概念及算法的评价。
基于Asp .net、XML与Flash架构的火车车厢重排问题虚拟实验开发
基于、XML与Flash架构的火车车厢重排问题虚拟实验开发摘要：当前，XML（Extensible Makeup Language）是跨平台数据结构的最佳选择，应用广泛。
它是一种通用的、跨平台的数据描述方法，相比于一般的记事本文件，完全采用了Unicode 编码和条理清晰的分层标签。
介绍了和Flash之间通过XML文件传递信息解决火车重排堆栈问题。
Flash使抽象的数据结构问题转化为具象的动画呈现给学生，有助于学生理解问题、编写程序。
关键词：XML；；Flash；虚拟实验；火车车厢重排0引言当前，XML是跨平台数据结构的最佳选择。
XML全称为可扩展标记语言（Extensible Makeup Language）。
它是一种通用的、跨平台的数据描述方法，也是未来存储信息的方式，其应用无处不在。
XML是可扩展的、与平台无关的语言，相比于一般记事本文件，它完全采用Unicode 编码和条理清晰的分层标签并且支持国际化。
Flash是专业的动画创作工具，可以开发有吸引力、表现力的用户界面和丰富的应用程序。
它开发的文件数据量小，可以以插件方式工作、“流”形式文件播放以及实时交互。
因此，Flash成功地渗入到网络动画、音乐电视、广告、教学、游戏等多个领域。
是基于通用语言的编译运行程序，其强大的适应性，几乎可以使它运行在Web 应用软件开发者全部的平台上。
通用语言的基本库、消息机制、数据接口的处理都能无缝整合到的Web应用中。
也是languageindependent（语言独立化）的，支持C#（C++和Java的结合体）、VB、Jscript、C++、F++等语言。
与Flash之间传值在中对数据进行处理后，生成XML树，然后通过XML 文件在Flash端接收XML文件，解析XML树后，根据传入的参数进行操作。
<sup>[1]</sup>其通信原理如图1所示。
端生成XML文件的代码如下：System.Xml.XmlTextWriter xmlWriter = new XmlTextWriter （Server.MapPath（"./1234.xml"），System.Text.Encoding.UTF8）；//声明一个xmlWriter变量用于编写XML文件xmlWriter.Formatting = Formatting.Indented；//用于生成良好的显示格式，增强可读性xmlWriter.WriteStartDocument（）；xmlWriter.WriteStartElement（"数据"）；//生成一个结点xmlWriter.WriteStartElement（"单次"）；xmlWriter.WriteAttributeString（"车厢"，firstNum.ToString（））；//写入节点的属性xmlWriter.WriteAttributeString（"铁轨"，secondNum.ToString（））；xmlWriter.WriteAttributeString（"出入"，thirdNum.ToString（））；xmlWriter.WriteEndElement（）；xmlWriter.WriteEndDocument（）；//写文档结束xmlWriter.Close（）；//关闭textWriterFlash端接收XML文件的代码如下：var myXML：XML= new XML；var XML_URL：String = "1234.xml"；var myXMLURL：URLRequest = new URLRequest（XML_URL）；public var myLoader：URLLoader = new URLLoader （myXMLURL）；public function Motion（）{myLoader.addEventListener（"complete"，xmlLoaded）；}2火车重排堆栈问题动画实现笔者在学习数据结构时发现授课内容比较抽象，需要具体的图解动态地描述问题。
火车车厢重排问题
⽕车车厢重排问题2014-11-04主要数据结构：栈题⽬：⼀列⽕车要将n节车厢分别送往n个车站按1~n的次序编号，⽕车按照n,n-1,…1的编号次序经过车站。
假设车厢的编号就是其⽬的地车站的编号。
要求：给定⼀个任意的车厢排列次序。
重新排列车厢，使其按照从1到n的次序排列。
规定重排时，只能从⼊轨到缓冲铁轨，或者从缓冲铁轨到出轨。
总的思路：⾸先：将所需要重排的车厢编号从左到右依次输⼊数组carrage中；然后：对carrage中的元素进⾏从左往右逐个遍历，如果符合下⼀个输出，则直接将其输出，并且遍历所有的缓冲轨道，查找是否有符合下⼀个输出的车厢，有的话便将其输出，否则将其压⼊缓冲轨道未经优化的代码：1 #include <iostream>2 #include <stack>3using namespace std;45 stack<int> stack_final;678void Output(int& minH, int& minS, stack<int> H[], int k, int n) {9// put the car from the strack to the output line, and change the minH and minS10int index; // the index of the car11//delete the minist car number from the minS12 stack_final.push(H[minS].top());13 H[minS].pop();14 cout << "Move car " << minH << "from holding track " << minS << " to output line" << endl;15//serch all the track's top, find the new minH and minS16 minH = n+2;17for (int i= 0; i < k; i++) {18if (!H[i].empty() && (index = H[i].top()) < minH) {19 minH = index;20 minS = i;21 }22 }23 }2425bool Input(int c, int& minH, int& minS, stack<int> H[], int k, int n) {26// put the new car c into the track27// if there is no available track, then return false, else return true28// find the best track for the car c29// initial30int BestTrack = 0; //the best track now31int BestTop = n+1; //the best track's top car32int index; //the index for the car33// search the k track34for (int i= 0; i < k; i++) {35if (!H[i].empty()) {36 index = H[i].top();37if (c < index && index < BestTop) {38//the top car's number is the smallest39 BestTop = index;40 BestTrack = i;41 }42 } else { // the track is empty43if (!BestTrack) {44 BestTrack = i;45 }46 }47 }48if (!BestTrack) {49return false; //there is available track to use50 }51 H[BestTrack].push(c);52 cout << "Move car " << c << "from input to holding track " << BestTrack << endl;53//if it is essencial, then change the minH and minS54if (c < minH) {55 minH = c;56 minS = BestTrack;57 }58return true;59 }6061bool Railroad(int input[], int n, int k) {62//k63// if it resort succed, then return true, else return false64// create the stack according to the k65 stack<int> *H;66 H = new stack<int> [k];67int NowOut = 1; // the next number of car to putout68int minH = n+1; //the minist number car in the k69int minS; //the minist number's strack70// resort the car71for (int i = n-1; i >= 0; i--) {72int number = input[i];73if (number == NowOut) {74 cout << "Move car " << number << " from the input line to the output line\n";75 stack_final.push(number);76 NowOut++;77while (minH == NowOut) {78 Output (minH, minS, H, k, n);79 NowOut++;80 }81 } else {82int end = 0;83for (int j = i; j > 0; j--) {84if (input[j-1] < input[j]) {85 end = j;86break;87 }88 }89for (int j = end; j <= i; j++) {90if (!Input (input[j], minH, minS, H, k, n)) {91return false;92 }93 }94if (end) {95 i = end;96 }97 }98 }99return true;100 }101102int main() {103int n, *input;104 cin >> n;105 input = new int[n];106for (int i = 0; i < n; i++) {107 cin >> input[i];108 }109if (Railroad(input, n, n-1)) {110 cout << "resort succed!\n";111while (!stack_final.empty()) {112 cout << stack_final.top() << "";113 stack_final.pop();114 }115 } else {116 cout << "failed\n";117 }118 }View Code经过优化之后的代码：增加的条件：车厢可以从排在后⾯的缓冲轨道移到前⾯的缓冲轨道。
队列
9/10/2012
35
火车车厢重排-约束
1. 2. 3.
仅允许以下移动： 入轨右端->缓冲铁轨 入轨右端->出轨 缓冲铁轨右端->出轨
9/10/2012
36
火车车厢重排方案
从前至后依次检查入轨上的所有车厢。 如果正在检查的车厢就是下一个满足排列要 求的车厢，可以直接把它放到出轨上去。如 果不是，则把它移动到缓冲铁轨上，直到按 输出次序要求轮到它时才将它放到出轨上。 重排演示。
9/10/2012
17
公式化类Queue
template<class T> T Queue<T>::First() const {// 返回队列的第一个元素 // 如果队列为空，则引发异常OutOfBounds if (IsEmpty()) throw OutOfBounds(); return queue[(front + 1) % MaxSize]; }
9/10/2012
30
返回队列的最后一个元素
template<class T> T LinkedQueue<T>::Last() const {// 返回队列的最后一个元素 // 如果队列为空，则引发异常O u t O f B o u n d s if (IsEmpty()) throw OutOfBounds(); return rear->data; }
9/10/2012
19
公式化类Queue
template<class T> Queue<T>& Queue<T>::Add(const T& x) {// 把x 添加到队列的尾部 // 如果队列满，则引发异常NoMem if (IsFull()) throw NoMem(); rear = (rear + 1) % MaxSize; queue[rear] = x; return *this; }
火车调度c语言程序实现代码
火车调度c语言程序实现代码(总3页)本页仅作为文档封面，使用时可以删除This document is for reference only-rar21year.March#define MAXSIZE 100/* 栈、队列的最大容量，设为100 */#include <>#include <>typedef char datatype;typedef struct {datatype stack[MAXSIZE]; /* 装载栈的向量 */int top; /* 栈顶指针 */} seqstack; /* 顺序栈类型定义*/typedef struct{ datatype queue[MAXSIZE];/* MAXSIZE为队列的最大长度 */int front;int rear;} sequeue; /* 顺序队列类型定义*/void setstacknull(seqstack *s ) /* 置空栈 */{ s->top=-1; }datatype pop(seqstack *s ) /* 出栈 */{ if (s->top<0 ){ printf( "stack empty！\n" );return('\0');}else{ s->top--; /* 产生新栈顶指针 */return(s->stack[s->top+1]); /* 返回原栈顶元素值 */ }}int empty(seqstack *s) /* 判断是否为空栈 */{if (s->top<0 ) return(1);else return(0);}void push(seqstack *s,datatype x) /* 入栈 */{ if ( s->top>=MAXSIZE-1 ) /* 上溢 */printf( "stack overflow！\n" );else{ s->top=s->top+1; /* 1.栈顶指针加1 */s->stack[s->top]=x; /* 2.新元素入栈 */}}void setseqnull(sequeue *sq) /* 置空队列 */{sq->front=-1; sq->rear=-1; }void encyque(sequeue *sq,datatype x) /* 入队 */ {if((sq->rear+1)%MAXSIZE==sq->front)printf( "queue overflow！\n" );else{ sq->rear=(sq->rear+1)%MAXSIZE;sq->queue[sq->rear]=x;}}datatype delcyque(sequeue *sq) /* 出队 */{if(sq->front==sq->rear)return(NULL);else{ sq->front=(sq->front+1)%MAXSIZE;return(sq->queue[sq->front]);}}main( ){seqstack *st;sequeue *trainsq;char ch, trains[MAXSIZE],*p=trains;st=(seqstack *)malloc(sizeof(seqstack));trainsq=(sequeue *)malloc(sizeof(sequeue));setstacknull(st);setseqnull(trainsq);printf("enter train serious:\n");gets(trains);putchar('\n');ch=*p;while (ch!='\0'){ ch=*p;if (ch=='L'){ push(st,ch);ch=pop(st);encyque(trainsq,ch);}else{push(st,ch);}p=p+1;}int i=0;p=trains;while(!empty(st)) {ch=pop(st); if(ch=='Q')encyque(trainsq,ch);else{*p=ch;p++;i++;}}if(i>=0){ch=trains[i];push(st,ch);ch=pop(st);encyque(trainsq,ch);i--;}printf("new train serious:\n");while (ch=delcyque(trainsq)) putchar(ch); putchar('\n');}。
c语言队列数据结构
c语言队列数据结构队列是一种常见的数据结构，它遵循先进先出（FIFO）的原则。
在C语言中，我们可以使用数组或链表来实现队列数据结构。
本文将介绍C语言中队列的实现方法及其应用。
一、数组实现队列数组是一种简单且常用的数据结构，可以用来实现队列。
在C语言中，我们可以使用数组来创建一个固定大小的队列。
下面是一个使用数组实现队列的示例代码：```c#include <stdio.h>#define MAX_SIZE 100int queue[MAX_SIZE];int front = -1;int rear = -1;void enqueue(int data) {if (rear == MAX_SIZE - 1) {printf("队列已满，无法插入元素。
\n");return;}if (front == -1) {front = 0;}rear++;queue[rear] = data;}void dequeue() {if (front == -1 || front > rear) {printf("队列为空，无法删除元素。
\n"); return;}front++;}int getFront() {if (front == -1 || front > rear) {printf("队列为空。
\n");return -1;}return queue[front];}int isEmpty() {if (front == -1 || front > rear) {return 1;}return 0;}int main() {enqueue(1);enqueue(2);enqueue(3);printf("队列的第一个元素：%d\n", getFront());dequeue();printf("队列的第一个元素：%d\n", getFront());return 0;}```在上述代码中，我们使用了一个数组`queue`来存储队列的元素。
火车调度C++代码
#include<iostream>#include<stack>using namespace std;int main() {int n,i,j,k=0,num;bool hold=false;cin>>n;//输入要调节的火车车厢的个数stack<int> *a = new stack<int> [n-1];//定义n-1个缓冲轨cin>>num;cout<<"the "<<num<<" carriage drives into the 1 rail"<<endl;a[k].push(num);for(i=0;i<n-1;++i){//读取车厢号cin>>num;for(j=0;j<=k;++j) {if(num<a[j].top()) {//如果输入的车厢号比这个缓冲轨的顶部元素小的话，则压入缓冲轨中a[j].push(num);cout<<"the "<<num<<" carriage drives into the "<<j+1<<" rail"<<endl;break;}if(j==k&&k==n-2){//如果缓冲轨被用了n-1个，还差一个不能驶入其中的话，说明其输入为hold=true; //顺序的1到n，记录为true.break;}if(j==k) {//如果该车厢号不能压入原先的k个缓冲轨中，则压入新的缓冲轨中，并记录使用a[k+1].push(num);//缓冲轨的个数k。
cout<<"the "<<num<<" carriage drives into the "<<k+2<<" rail"<<endl;++k;break;}}}if(hold==true) {//如果是确认了输入为顺序的1到n，则按照如下方式输出for(i=0;i<n-1;++i){//cout<<a[i].top()<<" ";cout<<"the "<<a[i].top()<<" carriage drives out from the "<<i+1<<" rail"<<endl;a[i].pop();}//cout<<num;//输出最后一个没能入缓冲轨的车厢cout<<"the last carriage "<<num<<" was not drove into the rail and it is out"<<endl;}else {//如果不是顺序期望输入，则按照如下方式输出for(i=1;i<=n;++i)for(j=0;j<=k;++j){if(a[j].empty()==false&&a[j].top()==i) {//在各个缓冲轨中寻找并输出期望车厢号//cout<<a[j].top()<<" ";cout<<"the "<<a[j].top()<<" carriage drives out from the "<<j+1<<" rail"<<endl;a[j].pop();//输出车厢号后弹出缓冲轨break;}}}return 0;}。
火车车厢重排问题栈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. ```。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
{ 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++) {
计算机科学与工程学院
《算法与数据结构》试验报告[一]
专业班级 学生学号
学生
10 级计算机工程 02 1005080222 肖宇博
试验地点 指导教师 试验时间
计算机大楼计工教研室 蔡琼
2012-4-21
试验项目
试验类别
试 验 目 的 及 要 求
算法与数据结构 基础性（） 设计性（） 综合性（√） 其它（ ）
3.2 否则，考察每一个缓冲轨队列 for (j=1; j<=k; j++) 3.2.1 取队列 j 的队头元素c； 3.2.2 如果c=nowOut，则 3.2.2.1 将队列 j 的队头元素出队并输出； 3.2.2.2 nowOut++；
3.3 如果入轨和缓冲轨的队头元素没有编号为nowOut的车厢，则 3.3.1 求小于入轨中第一个车厢编号的最大队尾元素所在队列编号j; 3.3.2 如果 j 存在，则把入轨中的第一个车厢移至缓冲轨 j； 3.3.2 如果 j 不存在，但有多于一个空缓冲轨，则把入轨中的第一个车厢移至一个 空缓冲轨；否则车厢无法重排，算法结束；
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++;
（1）掌握队列的特点及其存储方法； （2）掌握队列的常见算法和程序实现。
类别 上机表现 程序与报告
成绩评定表
评分标准
分值
积极出勤、遵守纪律 主动完成设计任务
30 分
程序代码规、功能正确 报告详实完整、体现收获
70 分
得分
合计
备注：
评阅教师： 日 期：
年月日
试验 容
一、实验目的和要求
1、实验目的： （1）掌握队列的特点及其存储方法； （2）掌握队列的常见算法和程序实现。
printf("请输入正确的车厢号!\n"); printf("****************************************************"); printf("\n"); goto label; } label2: printf("输入重排前的序列\n"); for(int i=1;i<=k;i++) { scanf("%d",&a[i]); enqueue(q,a[i]); } int r=examenter(a,k); if(r==0) { printf("您的输入车厢号有误! 请输入连续自然数:\n");
58
4321
入轨
H3
7
出轨
H2
(b) 将 1 移至出轨，234 移至 出轨
H1
987654321
入轨
H3
出轨
H2 (d) 将 6789 移至出轨
1. 分别对k个队列初始化； 2. 初始化下一个要输出的车厢编号nowOut = 1; 3. 依次取入轨中的每一个车厢的编号；
3.1 如果入轨中的车厢编号等于nowOut，则 3.1.1 输出该车厢； 3.1.2 nowOut++；
3、实验要求： 使用顺序存储队列的方式完成该实验。
二、设计分析
根据实验要求，采用队列来完成本次实验。 实验中定义了三个队列，一个用来存储输入的车厢号，另两个用来存储缓 存出队顺序及序号。
三、源程序代码
#include<stdio.h> #include<stdlib.h>
#define Max 20 typedef struct {
}
} }
} }
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) {
2、实验容: 火车车厢重排问题。
转轨站示意图如下：
H1
581742963
H3
入轨
H2
987654321
出轨
963
H1
581
入轨
H3
742
出轨
H2 (a) 将 369、247 依次入缓冲轨
96
H1
5
54321
入轨
H3
87
Hale Waihona Puke 出轨H2 (c) 将 8 入缓冲轨，5 移至出轨
火车车厢重排算法伪代码如下：
96
H1
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) {
return q->data[q->front+1]; }
if(c>n1) {
enqueue(w1,c); dequeue(q); } else { enqueue(w2,c); dequeue(q);
} } else {
if(c>n2) {
enqueue(w2,c); dequeue(q); } else { enqueue(w1,c); dequeue(q);
dequeue(w1);
} 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) {
int data[Max]; int front,rear; }squeue;
void initqueue(squeue *&q) {
q=(squeue *)malloc(sizeof(squeue)); q->front=q->rear=0; }
void enqueue(squeue *&q,int e) {