火车车厢重排 问题解决 c++(队列方法)
数据结构课程标准
1 课程标准1.1 课程定位《数据结构》是计算机类专业的核心课程之一，是软件技术专业必修的专业基础课程，也是其它非计算机专业的主要选修课程之一。
数据结构研究的范围和计算机软件有着密切的关系，无论是编译源程序还是操作系统，都涉及到数据元素在存储器中如何分配的问题。
在研究信息检索时也必须考虑如何组织这些数据，以便使查找和存取数据元素更为高效。
因此，可以认为数据结构是介于数学、计算机硬件和计算机软件三者之间的一门核心课程，在计算机科学中，数据结构不仅是一般程序设计（特别是非数值计算的程序设计）的基础，而且是设计和实现编译程序、操作系统、数据系统及其它系统程序和大型应用程序的重要基础。
由于《数据结构》是一门理论性很强的课程，重在理论，而高职教学的主要目标是培养高级技术应用型人才，更加偏重于实践能力的培养，所以我们针对高职学生的特点，在教学过程中对《数据结构》课程进行了系列教学改革，并取得了较好的效果。
本课程以就业为导向，从高技能人才培养的要求出发，以强化技术应用能力培养为主线，构建理论教学体系和实践教学体系。
在教学内容上，按照理论知识够用的高职教育原则，根据学生知识能力、企业岗位能力要求等，弱化了无应用性或应用性不强的内容，强化了工程项目中常用的知识点，构建了必须的教学单元。
1.2 工作任务和课程目标1.2.1 工作任务及职业能力表1-1 工作任务与职业能力分析表1.2.2 课程目标本课程的主要目标是使学生深入了解数据结构的逻辑思想、实现方法和应用技术。
本课程追求理论联系实际，教学与实践相呼应。
灵活多样地采取了编程、拓展性学习、案例教学、讨论、报告，大型作业，科研项目等多种形式，激发学生的学习兴趣和主动参与精神，使学生理解原理，掌握方法，熟练应用，能够创造性地应用各种数据结构和算法设计性能优，效率高，可读性强，易维护的程序，解决实际问题，提高学生的学习能力，探索研究的能力。
根据课程面对的工作任务和职业能力要求，本课程的教学目标为：（1）知识目标1）数据结构的基本概念及算法的评价。
排队问题的三种方法
排队问题的三种方法
排队问题的三种方法如下:
1. 经典方法:经典方法是解决排队问题的一种方法。
这种方法基于队列的基本概念,将排队系统中的元素看作队列中的元素,并考虑一些基本的操作,如插入、删除和移动元素。
经典方法通常包括以下步骤:
- 确定元素数目和优先级。
- 创建一个初始队列,并确定队列长度。
- 确定哪些元素需要移动到新的位置。
- 确定哪些元素需要删除。
- 执行操作,并将结果更新队列。
2. 动态规划方法:动态规划方法是解决排队问题的一种重要方法。
这种方法将问题划分为若干个子问题,并使用状态转移方程来解决问题。
状态转移方程通常包括以下步骤:
- 确定当前队列中元素数目和优先级。
- 根据优先级和元素数目,确定新状态。
- 在新状态中,根据优先级和元素数目,确定新队列的长度和元素数目。
- 根据新状态,解决问题。
3. 贪心算法:贪心算法是解决排队问题的一种重要方法。
这种方法假设元素具有一些基本性质,例如都具有一定的优先级和数目,并根据这些性质来解决问题。
贪心算法通常包括以下步骤:
- 确定当前队列中元素数目和优先级。
- 根据优先级和元素数目,确定新元素的可能性。
- 确定最可能的新元素,并插入到队列中。
- 如果新元素插入后,队列长度发生变化,重新考虑最可能的新元素。
火车车厢重排问题
⽕车车厢重排问题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经过优化之后的代码：增加的条件：车厢可以从排在后⾯的缓冲轨道移到前⾯的缓冲轨道。
火车调度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++代码
#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. ```。
《数据结构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.}。
车厢重组(信息学奥赛一本通-T1310)
【题目描述】
在一个旧式的火车站旁边有一座桥，其桥面可以绕河中心的桥墩水平旋转。
一个车站的职工发现桥的长度最多能容纳两节车厢，如果将桥旋转180度，则可以把相邻两节车厢的位置交换，用这种方法可以重新排列车厢的顺序。
于是他就负责用这座桥将进站的车厢按车厢号从小到大排列。
他退休后，火车站决定将这一工作自动化，其中一项重要的工作是编一个程序，输入初始的车厢顺序，计算最少用多少步就能将车厢排序。
【输入】
有两行数据，第一行是车厢总数N（不大于10000），第二行是N个不同的数表示初始的车厢顺序。
【输出】
一个数据，是最少的旋转次数。
【输入样例】
4
4 3 2 1
【输出样例】
6
【源程序】
#include<iostream>
using namespace std;
int a[10100];
int main()
{
int n;
int i,j;
int temp,sum=0;
cin>>n;
for(i=1;i<=n;i++)
cin>>a[i];
for(i=1;i<=n;i++)
for(j=i+1;j<=n;j++)
if(a[i]>a[j])
{
temp=a[i];
a[i]=a[j];
a[j]=temp;
sum++;
}
cout<<sum<<endl;
return 0;
}。
车厢重组c语言
车厢重组c语言车厢重组是一道经典的排序算法问题，它是计算机科学中的重要考题之一。
在这道问题中，给定一个长度为 N 的整数数组，能通过一系列的操作来将其排序，每个操作都是将一个子数组中的所有元素翻转。
现在的问题是，最少需要几次操作才能将整个数组变成升序排列。
我们可以通过编写 C 语言程序来解决这道问题。
在下面的代码中，我们使用了一个名为 solve 的函数来进行求解。
该函数接受一个整数数组作为参数，返回一个整数值，即最小的操作次数。
代码如下：```c#include <stdio.h>int solve(int a[], int n) {int ans = 0;for (int i = 0; i < n; i++) {int s = i, t = n - 1;while (s < t && a[s] <= a[s + 1]) s++;while (s < t && a[t] >= a[t - 1]) t--;if (s == t) break;int k = s;while (k <= t && a[k] >= a[k - 1]) k++; ans++;if (s == 0 && t == n - 1) ans++;if (s > 0) ans++;if (t < n - 1) ans++;for (int i = s, j = t; i < j; i++, j--) {int tmp = a[i];a[i] = a[j];a[j] = tmp;}}return ans;}int main() {int a[] = {3, 2, 1, 4, 5};int n = sizeof(a) / sizeof(a[0]);printf("%d\n", solve(a, n));return 0;}```在上述代码中，我们首先定义了一个名为 solve 的函数来解决车厢重组问题。
火车车厢重排问题栈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;}```在这段代码中，我们定义了一个栈的数据结构，并实现了栈的初始化、入栈和出栈操作。
c 队列queue的用法
c 队列queue的用法队列（queue）是一种常用的数据结构，具有“先进先出”（First-In-First-Out，FIFO）的特点。
在队列中，元素的插入和删除操作分别在队列的末尾和前端进行。
队列常用于模拟排队、任务调度和缓存等场景。
在C语言中，我们可以使用数组或链表实现队列的功能。
以下是一种使用数组实现的简单队列的示例：```c#include <stdio.h>#define MAX_SIZE 10//定义队列结构typedef struct {int items[MAX_SIZE];int front;int rear;} Queue;//初始化队列void initQueue(Queue *q) {q->front = -1;q->rear = -1;}//判断队列是否为空int isEmpty(Queue *q) {return (q->front == -1 && q->rear == -1); }//判断队列是否已满int isFull(Queue *q) {return (q->rear == MAX_SIZE - 1);//入队操作void enqueue(Queue *q, int data) { if (isFull(q)) {printf("队列已满，无法入队\n"); return;}if (isEmpty(q)) {q->front = q->rear = 0;} else {q->rear++;}q->items[q->rear] = data;printf("元素%d已入队\n", data);//出队操作void dequeue(Queue *q) {if (isEmpty(q)) {printf("队列为空，无法出队\n"); return;}int data = q->items[q->front]; if (q->front == q->rear) {q->front = q->rear = -1;} else {q->front++;}printf("元素%d已出队\n", data);int main() { Queue q; initQueue(&q); enqueue(&q, 1); enqueue(&q, 2); enqueue(&q, 3); dequeue(&q); dequeue(&q); dequeue(&q); dequeue(&q); return 0;}```在上述代码中，我们定义了一个`Queue`结构体，包含一个固定大小的整型数组`items`用于存储队列元素，以及两个整型变量`front`和`rear`表示队列的前端和末尾。
火车重排问题C++代码
a[m].EnterQueue(arr[i]);//入队
i++;//i加一实现了对下一个车厢的操作
p=1;//重新置为1
break; }
}
}
if(p==0) //表示上一节车厢没有被处理，程序结束
{
{ Node<T> *p=front->next;
while(p)
{
if(p==NULL)
break;
else
{
cout<<p->data<<' ';
p=p->next;
}
};
}
void main()
{ int n,k,t;
cin>>k;
if(k<=0) throw"必须存在缓冲轨道!";
cout<<"请依次输入火车车车厢号"<<endl;
for(int i=0;i<n;i++)
{
cin>>main[i];
}
cout<<endl;
LinkQueue<int> *huan;
huan=new LinkQueue<int>[k];
s->next=NULL;
rear->next=s;
rear=s;
}
template<class T>
T LinkQueue<T>::DeQueue()
{
if(rear==front) throw"发生下溢";
队列应用-车厢重排
数据结构实验报告实验名称：实验四队列的应用学生姓名：班级：班内序号：15学号：日期：2016.12.211．实验要求题目二：队列的应用利用队列结构实现车厢重排问题。
车厢重排问题如下：一列货车共有n节车厢，每个车厢都有自己的编号，编号范围从1~n。
给定任意次序的车厢，通过转轨站将车厢编号按顺序重新排成1~n。
转轨站共有k个缓冲轨，缓冲轨位于入轨和出轨之间。
开始时，车厢从入轨进入缓冲轨，经过缓冲轨的重排后，按1~n的顺序进入出轨。
缓冲轨按照先进先出方式，编写一个算法，将任意次序的车厢进行重排，输出每个缓冲轨中的车厢编号。
提示：1、一列火车的每个车厢按顺序从入轨进入不同缓冲轨，缓冲轨重排后的进入出轨，重新编排成一列货车。
比如：编号为3的车厢进入缓冲轨1，则下一个编号小于3的车厢则必须进入下一个缓冲轨2，而编号大于3的车厢则进入缓冲轨1，排在3号车厢的后面，这样，出轨的时候才可以按照从小到大的顺序重新编排。
2. 程序分析2.1 存储结构我使用了线性表的链式存储结构，通过建立单链表进行顺序存取初始车厢编号。
每个节点分为data、next。
data域称为数据域，数据通过node结构存储车厢编号；next为指针域，用来储存直接后继的地址。
struct node{int data;node*next;};2.2 程序流程(或程序结构、或类关系图等表明程序构成的内容，一般为流程图等)class LinkQueue{private:node*front;node*rear;public:LinkQueue() //无参构造函数{front = rear = new node;front->next = NULL;}void EnQueue(int x); //入队void show(int num); //输出缓冲轨~LinkQueue(); //析构函数};void line(int*zzj, LinkQueue*jay, int n) //建立缓冲轨队列2.3 关键算法分析入队函数：通过尾插法进行链表队列的入队操作。
队列的应用火车车厢重排问题
一、试验课题队列的应用实验目的：（1）掌握队列的特点及其存储方法；（2）掌握队列的常见算法和程序实现。
二、试验内容(1)问题描述：一列货运列车共有n节车厢，每节车厢将停放在不同的车站。
假定n个车站的编号分别为1~n，即货运列车按照第n站至第1站的次序经过这些车站。
为了便于从列车上卸掉相应的车厢，车厢的编号应与车站的编号相同，这样，在每个车站只要卸掉最后一节车厢。
所以，给定任意次序的车厢，必须重新排列它们。
车厢的重排工作可以通过国转轨站完成。
在转轨站中有一个入轨、一个出轨和k个缓冲轨，缓冲轨位于入轨和出轨之间。
假定缓冲轨按先进先出飞方式运作，设计算法解决火车车厢重排问题。
(2)基本要求：设计存储结构表示n个车厢、k个缓冲轨以及入轨和出轨;设计并实现车厢重排算法；分析算法的时间性能三、试验分析实验说明：转轨站示意图如下：2222(a) 将369、247依次入缓冲轨(b) 将1移至出轨，234移至出轨(c) 将8入缓冲轨，5移至出轨(d) 将6789移至出轨火车车厢重排过程如下：火车车厢重排算法伪代码如下：四、源程序代码#include<iostream>using namespace std;const MS=100;template <class T>struct QNode{T data;QNode<T> *next;};template <class T>class LiQueue{public:LiQueue( ); //构造函数，初始化一个空的链队列~LiQueue( ); //析构函数，释放链队列中各结点的存储空间void EnQueue(T x); //将元素x入队T DeQueue( ); //将队头元素出队T GetFront( ); //取链队列的队头元素T GetRear();bool Empty( ); //判断链队列是否为空QNode<T> *front, *rear; //队头和队尾指针，分别指向头结点和终端结点};template <class T>LiQueue<T>::LiQueue( ){QNode <T> *s;s=new QNode<T>;s->next=NULL;front=rear=s;}template <class T>LiQueue<T>::~LiQueue( ){QNode <T> *p;while(front){p=front;front=front->next;delete p;}}template <class T>void LiQueue<T>::EnQueue(T x){QNode<T> *s;s=new QNode<T>;s->data=x; //申请一个数据域为x的结点ss->next=NULL;rear->next=s; //将结点s插入到队尾rear=s;}template <class T>T LiQueue<T>::DeQueue(){QNode <T> *p; int x;if (rear==front) throw "下溢";p=front->next;x=p->data; //暂存队头元素front->next=p->next; //将队头元素所在结点摘链if (p->next==NULL) rear=front; //判断出队前队列长度是否为1delete p;return x;}template <class T>T LiQueue<T>::GetFront(){if (rear!=front)return front->next->data;}template <class T>T LiQueue<T>::GetRear(){if(rear!=front)return rear->data;}template <class T>bool LiQueue<T>::Empty( ){if(front==rear) return 0;else return 1;}class Train{private :int n,k,th;public :Train();void ChongPai();};Train::Train(){cout<<"请输入火车(货运列车）的车厢个数为："<<endl;cin>>n;cout<<"请输入转轨站的缓冲轨个数为："<<endl;cin>>k;}void Train::ChongPai(){int a[MS];LiQueue<int>*b;b=new LiQueue<int>[k+2];cout<<"请输入车厢入轨编号次序："<<endl;for(int i=0;i<n;i++)cin>>a[i];for(i=n-1;i>=0;i--)b[k].EnQueue(a[i]);cout<<"则进行车厢重排过程如下:"<<endl;th=1;while(b[k].Empty()){int xx=b[k].DeQueue();if(xx==th){cout<<th<<"号车厢直接移至出轨"<<endl;b[k+1].EnQueue(th);th++;int j=0;while(b[j].Empty()){int x=b[j].GetFront();if(x==th){cout<<x<<"号车厢从"<<j+1<<"号缓冲轨出轨"<<endl;b[j].DeQueue();b[k+1].EnQueue(x);j=0;th++;}elsej++;}continue;}else{int j=0,u=5;while(b[j].Empty()&&j<k){if(xx<b[j].GetRear())j++;else{cout<<xx<<"号车厢移至"<<j+1<<"号缓冲轨"<<endl;b[j].EnQueue(xx);u=1;break;}}if(u==5&&j<k){cout<<xx<<"号车厢移至"<<j+1<<"号缓冲轨"<<endl;b[j].EnQueue(xx);}if(j==k-1){cout<<"\n缓冲轨不够，重排车厢失败\n";return;}}}cout<<"车厢依次出轨的编号为：";while(b[k+1].Empty())cout<<b[k+1].DeQueue()<<" ";cout<<endl;}void main(){Train a;a.ChongPai();}五、测试用例1.当有9个火车车厢，3个缓冲轨道时，运行结果如下：2. 当有12个火车车厢，3个缓冲轨道时，运行结果如下：3. 当有12个火车车厢，5个缓冲轨道，运行结果如下：4. 当有12个火车车厢，7个缓冲轨道时，运行结果如下：几次测试都表明试验设计的正确性。
c++数据结构用队列实现火车车厢重排问题,分头文件的完整面向对象代码
bool flag=1;//标记
while(i<n&&flag){ //当入轨中有车厢时
flag=0;
for(int m=0;m<k;m++){ //判断缓冲轨的队尾元素与入轨的元素
if(a[m].GetRear()<arr[i]){
a[m].EnQueue(arr[i]);
}
friend void TrainPermute(int arr[],LinkQueue<T> a[],int n,int k);
};
template<typename T>
LinkQueue<T>::LinkQueue(){
Node<T> *s=new Node<T>;
s->next=NULL;
if(rear==front)
throw"下溢";
Node<T> *p=front->next;
int x=p->data;
front->next=p->next;
if(p->next==NULL)
rear=front;
delete p;
return x;
}
}
else
{
for(int m=0;m<k;m++){
cout<<"第"<<(m+1)<<"个缓冲轨的列车编号\t";
a[m].Trans();
cout<<endl;
队列的应用火车车厢重排问题
一、试验课题队列的应用实验目的：（1）掌握队列的特点及其存储方法；（2）掌握队列的常见算法和程序实现。
二、试验内容(1)问题描述：一列货运列车共有n节车厢，每节车厢将停放在不同的车站。
假定n个车站的编号分别为1~n，即货运列车按照第n站至第1站的次序经过这些车站。
为了便于从列车上卸掉相应的车厢，车厢的编号应与车站的编号相同，这样，在每个车站只要卸掉最后一节车厢。
所以，给定任意次序的车厢，必须重新排列它们。
车厢的重排工作可以通过国转轨站完成。
在转轨站中有一个入轨、一个出轨和k个缓冲轨，缓冲轨位于入轨和出轨之间。
假定缓冲轨按先进先出飞方式运作，设计算法解决火车车厢重排问题。
(2)基本要求：设计存储结构表示n个车厢、k个缓冲轨以及入轨和出轨;设计并实现车厢重排算法；分析算法的时间性能三、试验分析实验说明：转轨站示意图如下：2222(a) 将369、247依次入缓冲轨 (b) 将1移至出轨，234移至出轨(c)将8入缓冲轨，5移至出轨 (d) 将6789移至出轨火车车厢重排过程如下：火车车厢重排算法伪代码如下：四、源程序代码#include<iostream>using namespace std;const MS=100;template <class T>struct QNode{T data;QNode<T> *next;};template <class T>class LiQueue{public:LiQueue( ); //构造函数，初始化一个空的链队列~LiQueue( ); //析构函数，释放链队列中各结点的存储空间void EnQueue(T x); //将元素x入队T DeQueue( ); //将队头元素出队T GetFront( ); //取链队列的队头元素T GetRear();bool Empty( ); //判断链队列是否为空QNode<T> *front, *rear; //队头和队尾指针，分别指向头结点和终端结点};template <class T>LiQueue<T>::LiQueue( ){QNode <T> *s;s=new QNode<T>;s->next=NULL;front=rear=s;}template <class T>LiQueue<T>::~LiQueue( ){QNode <T> *p;while(front){p=front;front=front->next;delete p;}}template <class T>void LiQueue<T>::EnQueue(T x){QNode<T> *s;s=new QNode<T>;s->data=x; //申请一个数据域为x的结点ss->next=NULL;rear->next=s; //将结点s插入到队尾 rear=s;}template <class T>T LiQueue<T>::DeQueue(){QNode <T> *p; int x;if (rear==front) throw "下溢";p=front->next;x=p->data; //暂存队头元素front->next=p->next; //将队头元素所在结点摘链if (p->next==NULL) rear=front; //判断出队前队列长度是否为1 delete p;return x;}template <class T>T LiQueue<T>::GetFront(){if (rear!=front)return front->next->data;}template <class T>T LiQueue<T>::GetRear(){if(rear!=front)return rear->data;}template <class T>bool LiQueue<T>::Empty( ){if(front==rear) return 0;else return 1;}class Train{private :int n,k,th;public :Train();void ChongPai();};Train::Train(){cout<<"请输入火车(货运列车）的车厢个数为："<<endl;cin>>n;cout<<"请输入转轨站的缓冲轨个数为："<<endl;cin>>k;}void Train::ChongPai(){int a[MS];LiQueue<int>*b;b=new LiQueue<int>[k+2];cout<<"请输入车厢入轨编号次序："<<endl;for(int i=0;i<n;i++)cin>>a[i];for(i=n-1;i>=0;i--)b[k].EnQueue(a[i]);cout<<"则进行车厢重排过程如下:"<<endl;th=1;while(b[k].Empty()){int xx=b[k].DeQueue();if(xx==th){cout<<th<<"号车厢直接移至出轨"<<endl;b[k+1].EnQueue(th);th++;int j=0;while(b[j].Empty()){int x=b[j].GetFront();if(x==th){cout<<x<<"号车厢从"<<j+1<<"号缓冲轨出轨"<<endl;b[j].DeQueue();b[k+1].EnQueue(x);j=0;th++;}elsej++;}continue;}else{int j=0,u=5;while(b[j].Empty()&&j<k){if(xx<b[j].GetRear())j++;else{cout<<xx<<"号车厢移至"<<j+1<<"号缓冲轨"<<endl;b[j].EnQueue(xx);u=1;break;}}if(u==5&&j<k){cout<<xx<<"号车厢移至"<<j+1<<"号缓冲轨"<<endl;b[j].EnQueue(xx);}if(j==k-1){cout<<"\n缓冲轨不够，重排车厢失败\n";return;}}}cout<<"车厢依次出轨的编号为：";while(b[k+1].Empty())cout<<b[k+1].DeQueue()<<" ";cout<<endl;}void main(){Train a;a.ChongPai();}五、测试用例1.当有9个火车车厢，3个缓冲轨道时，运行结果如下：2. 当有12个火车车厢，3个缓冲轨道时，运行结果如下：3. 当有12个火车车厢，5个缓冲轨道，运行结果如下：4. 当有12个火车车厢，7个缓冲轨道时，运行结果如下：几次测试都表明试验设计的正确性。
列车车厢号排列规则
列车车厢号排列规则
答：旅客列车车厢的顺序号有两种排列形式：
第一种，由北京和上海站始发的各次特快、直快列车，车厢的顺序号为数码小的在前，数码大的在后。
返回北京和上海时，车厢的顺序号为数码大的在前，数码小的在后。
北京和上海之间的旅客列车，以北京站规定的顺序为准。
比如，由北京至广州的数码小的车票的车厢一定在列车的前部；返回北京时，数码小的车厢在列车后部。
但要注意，有的列车在中途站停车时，要变换方向，这时大小号车厢的顺序要有变化。
第二种，非上海和北京站始发的旅客列车车厢顺序，是以担当乘务铁路局的始发站方向为准，数码小的在前，数码大的在后。
例如，郑州至乌鲁木齐的171/172次列车，都是由郑州铁路局担当乘务。
所以在郑州发车时，列车前部为数码小的号，后部为数码大的号，由乌鲁木齐返回时，则相反。
c 队列queue的用法
c 队列queue的用法【c 队列queue的用法】队列（Queue）是一种常见的数据结构，它遵循“先进先出”（First-In-First-Out, FIFO）的原则。
在计算机科学中，队列广泛应用于各种领域，例如操作系统的进程调度、网络数据包的传输和图形图像处理等。
本文将一步一步地介绍队列的基本概念、特性以及在编程中的用法。
一、队列的基本概念和特性队列是一种线性的数据结构，它是由一系列元素组成的集合，其中的元素按照插入的顺序排列，并且只能在队列的末尾进行插入操作，而只能从队列的头部进行删除操作。
这种插入在一端删除在另一端的特性使得队列符合了“先进先出”的原则。
在队列中，插入元素的操作称为入队（enqueue），删除元素的操作称为出队（dequeue）。
入队操作在队列的尾部进行，而出队操作则在队列的头部进行。
此外，队列还具有两个重要的特性：空队列和满队列。
空队列指的是队列中没有任何元素，而满队列指的是队列已满无法再插入新的元素。
二、队列的实现在编程中，我们可以利用数组或链表来实现队列。
下面我们将分别介绍这两种实现方式。
1. 数组实现采用数组实现队列时，我们需要定义两个指针：一个指向队列的头部，一个指向队列的尾部。
这两个指针可以通过变量进行记录。
入队操作是将元素插入到尾部指针所指的位置，然后将尾部指针后移；而出队操作是删除头部指针所指的元素，然后将头部指针后移。
2. 链表实现采用链表实现队列时，我们可以利用链表的尾节点来插入新元素，链表的头节点来删除元素。
入队操作是将元素插入到链表的尾节点之后，然后将尾节点指向新插入的节点；出队操作是删除链表的头节点。
三、队列的常用操作在队列的实现中，除了入队和出队操作之外，还有一些其他常用的操作，例如获取队列长度、判断队列是否为空、获取队头元素等。
下面我们将一一介绍这些操作。
1. 入队操作（enqueue）：将元素插入到队列的尾部。
2. 出队操作（dequeue）：删除队列的头部元素，并返回其值。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
火车车厢重排问题c++解决方法（队列实现）//Queue.h#ifndef QUEUE_H#define QUEUE_H#include<iostream>using namespace std;template<typename T>class Queue{public:virtual void MakeEmpty()=0;virtual void Enqueue(T x)=0;virtual T Dequeue()=0;virtual bool IsEmpty()const=0;virtual bool IsFull()const=0;virtual T GetFirstItem()=0;};class EmptyQueue{};class FullQueue{};#endif//LinkQueue.h //链表队列#ifndef LINKQUEUE_H#define LINKQUEUE_H#include<iostream>#include"Queue.h"using namespace std;template<typename T>struct Node{T date;Node<T> *next;};template<typename T>class LinkQueue:public Queue<T>{template<typename T>friend ostream & operator<<(ostream &s,const LinkQueue<T> &lq);public:LinkQueue();~LinkQueue();void MakeEmpty();void Enqueue(T x);T Dequeue();bool IsEmpty()const;bool IsFull()const;T GetFirstItem();T GetlastItem();private:Node<T> *front;Node<T> *rear;};template<typename T>LinkQueue<T>::LinkQueue(){front=new Node<T>;front->next=NULL;rear=front;}template<typename T>LinkQueue<T>::~LinkQueue(){MakeEmpty();delete front;}template<typename T>void LinkQueue<T>::Enqueue(T x) {Node<T> *newnode;newnode=new Node<T>;newnode->date=x;newnode->next=NULL;rear->next=newnode;rear=newnode;}template<typename T>T LinkQueue<T>::Dequeue(){if(IsEmpty())throw EmptyQueue();Node<T> *p;p=front->next;T x=p->date;front->next=p->next;if(p->next==NULL)rear=front;delete p;return x;}template<typename T>bool LinkQueue<T>::IsFull()const {return false;}template<typename T>bool LinkQueue<T>::IsEmpty()const {return front==rear;}template<typename T>T LinkQueue<T>::GetFirstItem() {if(IsEmpty())throw EmptyQueue();Node<T> *p;p=front->next;return p->date;}template<typename T>T LinkQueue<T>::GetlastItem() {if(IsEmpty())throw EmptyQueue();return rear->date;}template<typename T>void LinkQueue<T>::MakeEmpty() {Node<T> *p;while(front->next!=NULL){p=front->next;front->next=p->next;delete p;}}template <typename T>ostream & operator<<(ostream &s,const LinkQueue<T> &lq){Node<T> *p;p=lq.front->next;while(p!=NULL){s<<p->date<<" ";p=p->next;}return s;}#endif//TrainResort.h//火车车厢重排代码核心部分#ifndef TRAINRESORT#define TRAINRESORT#include<iostream>#include"LinkQueue.h"using namespace std;class TrainResort{friend ostream & operator <<(ostream &s,TrainResort &tr); public:TrainResort(LinkQueue<int> *or,int m=3);~TrainResort();private:int buf;LinkQueue<int> orbit;LinkQueue<int> *buffer;};TrainResort::TrainResort(LinkQueue<int> *or,int m){buf=m;while(!or->IsEmpty())orbit.Enqueue(or->Dequeue());buffer=new LinkQueue<int>[buf];}TrainResort::~TrainResort(){delete []buffer;}ostream & operator <<(ostream &s,TrainResort &tr){int nowOut=1;int temp;int x,y;int z;while(!tr.orbit.IsEmpty()){x=0,y=0;z=0;temp=tr.orbit.Dequeue();if(temp==nowOut){tr.buffer[0].Enqueue(nowOut);nowOut++;for(int j=1;j<tr.buf;j++){int k=0;while(!tr.buffer[j].IsEmpty()&&tr.buffer[j].GetFirstItem()==nowOu t){tr.buffer[0].Enqueue(nowOut);nowOut++;tr.buffer[j].Dequeue();k++;}if(k!=0){if(temp==nowOut){tr.buffer[0].Enqueue(nowOut);nowOut++;}j=0;}}}else{for(int j=1;j<tr.buf;j++){if(!tr.buffer[j].IsEmpty()){if(temp-tr.buffer[j].GetlastItem()>0){y=(x>temp-tr.buffer[j].GetlastItem()?y:j);x=(y==j?temp-tr.buffer[j].GetlastItem():x);}}else{z=j;}}if(y!=0){tr.buffer[y].Enqueue(temp);}else if(z!=0){tr.buffer[z].Enqueue(temp);}else{s<<"Don't resort!";break;}}}s<<tr.buffer[0];return s;}#endif。