火车队列算法

① 写出队列的入队及出队算法

入队算法
linklist in_queue(linklist rear,datatype x)
{
s=new lnode;
s->data=x;
s->next=rear->next;
rear->next=s;
rear=s;
return(rear );
}
出队算法
linklist out_queue(linklist rear,datatype *x)
{
if (rear->next==rear)
return(NULL);
q=rear->next->next;
if (q==rear)
{
rear=rear->next;
rear->next=rear;
}
else
{
rear->next->next=q->next;
}
*x=q->data;
delete q;
return(rear);
}

② 排队等火车在排队论里是什么分布

泊松分布适合于描述单位时间内随机事件发生的次数。如某一服务设施在一定时间内到达的人数，电话交换机接到呼叫的次数，汽车站台的候客人数，机器出现的故障数，自然灾害发生的次数等等。
排队规则遵从先到先服务的原则,且为等待制,即旅客接受售票服务是需要等待时间的,但是旅客可以根据窗口的排队情况选择到相对空闲的队列排队等待接受服务。旅客在售票窗口接受购票服务的时间是相互独立的,但是从整体来分析旅客接受服务的时间符合泊松分布规律。

③ 队列的队列的基本运算

（1）初始化队列：Init_Queue(q) ，初始条件：队q 不存在。操作结果：构造了一个空队；
（2）入队操作： In_Queue(q,x),初始条件： 队q 存在。操作结果： 对已存在的队列q，插入一个元素x 到队尾，队发生变化；
（3）出队操作： Out_Queue(q,x)，初始条件: 队q 存在且非空，操作结果： 删除队首元素，并返回其值，队发生变化；
（4）读队头元素：Front_Queue(q,x)，初始条件: 队q 存在且非空，操作结果： 读队头元素，并返回其值，队不变；
（5）判队空操作：Empty_Queue(q)，初始条件： 队q 存在，操作结果： 若q 为空队则返回为1，否则返回为0。 操作 类型 作用 返回值 例子 length(s) 函数 求字符串s的长度 整型 s:='123456789';
l:=length(s);{l的值为9} （s,w,k) 函数 复制s中从w开始的k位 字符串 s:='123456789';
s1:=(s,3,5);{s1的值是'34567'} val(s,k,code) 过程 将字符串s转为数值，存在k中；code是错误代码 var s:string;k,code:integer;
begin
s:='1234';
val(s,k,code);
write(k);{k=1234} str(i,s) 过程 将数值i转为字符串s i:=1234;
str(i,s);
write(s);{s='1234'} Delete(s,w,k) 过程 在s中删除从第w位开始的k个字符 s := 'Honest Abe Lincoln';
Delete(s,8,4);
Writeln(s); { 'Honest Lincoln' } Insert(s1, S, w) 过程 将s1插到s中第w位 S := 'Honest Lincoln';
Insert('Abe ', S, 8); { 'Honest Abe Lincoln' } Pos(c, S) 函数 求字符c在s中的位置 整型 S := ' 123.5';
i :=Pos(' ', S);{i的值为1} + 运算符 将两个字符串连接起来 s1:='1234';
s2:='5678';
s:=s1+s2;{'12345678'} 在STL中，对队列的使用很是较完美
下面给出循环队列的运算算法:
(1)将循环队列置为空
//将队列初始化
SeQueue::SeQueue()
{ front=0;
rear=0;
cout<<init!<<endl;
}
(2)判断循环队列是否为空
int SeQueue::Empty()
{ if(rear==front) return(1);
else return(0);
}
(3)在循环队列中插入新的元素x
void SeQueue::AddQ(ElemType x)
{ if((rear+1) % MAXSIZE==front) cout<< QUEUE IS FULL! <<endl;
else{ rear=(rear+1) % MAXSIZE;
elem[rear]=x;
cout<< OK!;
}
}
(4)删除队列中队首元素
ElemType SeQueue::DelQ()
{ if(front==rear)
{ cout<< QUEUE IS EMPTY! <<endl; return -1;}
else{ front=(front+1) % MAXSIZE;
return(elem[front]);
}
}
(5)取队列中的队首元素
ElemType SeQueue::Front()
{ ElemType x;
if(front== rear)
cout<<QUEUE IS EMPTY <<endl;
else x= elem[(front+1)%MAXSIZE];
return (x);
}

④ 火车车厢重排问题

#include <iostream> class Node { protected: int data; Node *next; Node(int n=0,Node*m=NULL):data(n),next(m){}//初始化节点对象 friend class Queue; }; class Queue//队列类 { protected: Node *front,*rear; public: Queue(); ~Queue(){}//析构函数 void EnQueue(int x); int DeQueue(); int GetFront(); int GetRear(); bool IsEmpty(); }; Queue::Queue()//构造函数 { Node *p; p=new Node; p->next=NULL; front=rear=p; } void Queue::EnQueue(int x)//进队 { Node *p; p=new Node; p->data=x; p->next=NULL; rear->next=p; rear=p; } int Queue::DeQueue()//出队 { Node*k; if(front==rear) return NULL; else { k=front->next; front->next=k->next; if(k->next==NULL) front=rear; int m=k->data; delete k; return m; } } int Queue::GetFront()//取队头元素 { if(front==rear) return NULL; else return front->next->data; } int Queue::GetRear()//取队尾元素 { if(front==rear) return NULL; else return rear->data; } bool Queue::IsEmpty()//判断队列为空 { return front==rear ; } int Find_MinH(Queue *H, int k)//求入轨到空缓冲轨中最优队列编号 { int n=0;int minH=k+1; for(int i=1;i<k+1;i++) { if(!H[i].IsEmpty()) n++; else minH=(minH>i)?i:minH; } if(n<k)return minH; else return 0; } int Find_MaxH(Queue *H,int k,Queue p)//求入轨到非空缓冲轨队列最优编号 { int maxHRear=0,maxH=0; for(int i=1;i<k+1;i++) { int x=0; if(p.GetFront()>H[i].GetRear()&&H[i].GetRear()>=maxHRear){ maxHRear=H[i].GetRear(); maxH=i; } } return maxH; } void Resort(Queue p,Queue *H,int k)//火车车厢重排 { int nowOut=1; while(nowOut<=9) { int flag=0;//车厢出轨标记初始化为0 if(p.GetFront()==nowOut) { int m=p.DeQueue(); std::cout<<m<<"\t"; nowOut++; flag=1; } else { for(int j=1;j<k+1;j++) { if(!H[j].IsEmpty()){ int c=H[j].GetFront(); if(c==nowOut) { int n=H[j].DeQueue(); std::cout<<n<<"\t"; nowOut++; flag=1; } } } } if(flag==0)//入轨和缓冲轨均无出队车厢 { int maxH=Find_MaxH(H,k,p);//求由入轨到非空缓冲轨的最优车厢编号 if(maxH!=0) { int h=p.DeQueue(); H[maxH].EnQueue(h); } else { int minH=Find_MinH(H,k);//求由入轨到空缓冲轨的最优车厢编号 if(minH>0) H[minH].EnQueue(p.DeQueue()); else //无空缓冲轨，重排算法结束 std::cout<<"无空缓冲轨，重排结束！"<<"\n"; } } } } void main() { Queue p; const int N=9; int a[N]={3,6,9,2,4,7,1,8,5}; std::cout<<"车厢重排后顺序："<<"\n"; for(int i=0;i<N;i++) std::cout<<a[i]<<"\t"; std::cout<<std::endl; for(int i=0;i<N;i++) p.EnQueue(a[i]); std::cout<<"车厢重排后顺序："<<"\n"; int k=2; /*Queue B; Queue C; Queue D; Queue E; Queue H[]={B,C,D,E};*/ Queue *H=new Queue[k+1]; Resort(p,H,k); }

⑤ 循环队列中入队与出队算法

如果循环队列每个元素有两个指针，一个指向其前面的元素pPre，一个指向后面的元素pNext，出对和入队就是修改一下指针啊。
比如指向要出队的元素的指针是 pDel,那么出队就应该是：
pDel->pPre->pNext = pDel->pNext;
pDel->pNext->pPre = pDel->pPre;

如果循环队列每个元素只有一个指向其后元素的指针pNext，那么需要遍历整个队列，找到要出队元素的前一个元素，然后就和上面的算法差不多了。

如果经常要进行出队操作，在设计数据结构的时候还是建议每个元素使用两个指针。

⑥ C程序模拟电梯,模拟火车调度,模拟银行排队系统哪个更难

看你想做成多大的吧，其实要想做复杂的话都很复杂的
都属于线程调度的问题，或者说资源分配的事情吧
火车调度分动车、快车、慢车、入站车与直达车等等调度
电梯调度存在多个电梯配合问题，小心容易出现死锁或出现资源长时间等待问题
银行排队系统也分企业客户与个人客户，是否存在排队机，排队过程中出现VIP客户，仅有限的几个窗口中存在大规模存取现金等长时间资源占用情况的出现。

无所谓哪个更难，因为要想做好就需要付出大量的努力。做作业没有必然现象，因为实际情况中有各种各样可能。你的收获不应该定位在哪个作业更大，我认为你应该将收获定位在：
1、就业中有可能遇到的情况（例如在银行、电梯设计单位、火车站工作）
2、你的发散式想象力，能够应对更多突发事件的情况
3、专业知识及专业能力中资源管理能力及线程调度能力
想做的简单些的话很简单，有追求进步的想法很值得夸奖，希望你能保持这种态度，努力把这东西做到更好。不要说能指望这东西在实际中能有多么广泛的用途，主要能够满足基本的要求，那么对学生来讲就能够有很大的收获了。祝你成功

⑦ 铁路怎样对火车进行调配

列车的运行、进站、出站、编组都有调度指挥系统控制，并且相关的监测、信号设备（包括硬件和软件）有专门的铁路局电务部门进行细致维护。
具体设备包括：
1.TDCS（列车调度指挥系统）：由中国铁通专网组网，设有极其严密的反病毒和防火墙设置，IP地址和口令频繁更换，负责执行全部调度方案；
2.站内（或区间线路所）计算机联锁设备或电气集中联锁设备：负责执行管内所有信号机的信号控制，道岔的定位与反位，并且严格执行它们之间严密的逻辑运算关系；
3.区间轨道电路自动闭塞系统：轨道电路负责执行验证运行列车前方，轨道是否被占用，与同线前行列车的追及距离，轨道是否完整良好等。目前主流的设备是ZPW2000A移频自动闭塞系统，轨道载频为1700Hz、2000Hz、2300Hz、2600Hz，调制方法为频移键控。
目前第六次提速后，我国的列车运行控制系统已达到CTCS-2级。
未来的CTCS-3\4\5，将会使用更先进的无线调度方案，GSM-R系统，目前该系统已在最新的青藏线、大秦线、胶济线运行。
本人是北京铁路局电务系统员工，希望回答能让你满意，祝你顺利:)

⑧ 队列初始化 入队列和出队列的算法

#include <iostream.h>
#include <stdlib.h>
void main()
{

}

#define Status bool
#define ElemType int
typedef struct list{
ElemType data;
struct list *next;
struct list *pre;
}*CLQueue;

Status InitCLQueue(CLQueue &rear)
{
CLQueue q = (CLQueue )malloc(sizeof(struct list));
rear = q;
rear->next = rear->pre = rear;
return true;
}

Status EnCLQueue(CLQueue &rear, ElemType x)
{
CLQueue q = (CLQueue)malloc(sizeof(struct list));
q->data = x;
if(rear->next == rear)
{
rear->next = rear->pre =q;
q->next = q->pre = rear;
rear = q;
}
else
{
q->pre = rear->next;
q->next = rear->next->next;
rear->next->next->pre = q;
rear->next->next = q;
}
return true;
}

Status DeCLQueue(CLQueue &rear, ElemType &x)
{
if(rear->next == rear) return false;
rear = rear->pre;
CLQueue q = rear->next;
q->next->pre = rear;
rear->next = q->next;
free(q);
return true;
}

⑨ C++用队列实现火车车厢重排问题

#include<iostream.h> const N=100; template <class T> struct Node { T data; Node<T> *next; //此处<T>也可以省略 }; template <class T> class LinkQueue { public: LinkQueue( ); //构造函数，初始化一个空的链队列 ~LinkQueue( ); //析构函数，释放链队列中各结点的存储空间 void EnQueue(T x); //将元素x入队 T DeQueue( ); //将队头元素出队 T GetQueue( ); //取链队列的队头元素 bool Empty( ); //判断链队列是否为空 Node<T> *front, *rear; //队头和队尾指针，分别指向头结点和终端结点 }; template <class T> LinkQueue<T>::LinkQueue( ) { Node <T> *s; s=new Node<T>; s->next=NULL; front=rear=s; } /* * 前置条件：队列存在 *输 入：无 *功 能：销毁队列 *输 出：无 * 后置条件：释放队列所占用的存储空间 */ template <class T> LinkQueue<T>::~LinkQueue( ) { while(front) { Node <T> *p; p=front->next; delete front; front=p; } } /* * 前置条件：队列已存在 *输 入：元素值s *功 能：在队尾插入一个元素 *输 出：无 * 后置条件：如果插入成功，队尾增加了一个元素 */ template <class T> void LinkQueue<T>::EnQueue(T x) { Node<T> *s; s=new Node<T>; s->data=x; //申请一个数据域为x的结点s s->next=NULL; rear->next=s; //将结点s插入到队尾 rear=s; } /* * 前置条件：队列已存在 *输 入：无 *功 能：删除队头元素 *输 出：如果删除成功，返回被删元素值，否则，抛出删除异常 * 后置条件：如果删除成功，队头减少了一个元素 */ template <class T> T LinkQueue<T>::DeQueue() { Node <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 LinkQueue<T>::GetQueue() { if (front!=rear) return front->next->data; } /* * 前置条件：队列已存在 *输 入：无 *功 能：判断队列是否为空 *输 出：如果队列为空，返回1，否则，返回0 * 后置条件：队列不变 */ template <class T> bool LinkQueue<T>::Empty( ) { if(front==rear) return 1; else return 0; } void Output(int& minH, int& minQ, LinkQueue<int> H[], int k, int n) { //从缓冲铁轨移动到出轨，并修改minH 和m i n Q . int c; // 车厢编号 // 从队列minQ 中删除编号最小的车厢minH H[minQ].DeQueue( ) ; cout << "Move car " << minH << " from holding track " << minQ << " to output" << endl; // 通过检查所有队列的首部，寻找新的m i n H和m i n Q minH= n+2; for (int i = 1; i <= k; i++) if (!H[i].Empty() &&(c = H[i].front->next->data) < minH) { minH = c; minQ = i; } } bool Hold(int c, int& minH, int &minQ, LinkQueue<int> H[], int k) { //把车厢c 移动到缓冲铁轨中 // 如果没有可用的缓冲铁轨，则返回f a l s e，否则返回t r u e // 为车厢c 寻找最优的缓冲铁轨 // 初始化 int BestTrack = 0, // 目前最优的铁轨 BestLast = 0, // BestTrack 中最后一节车厢 x; // 车厢编号 // 扫描缓冲铁轨 for (int i = 1; i <= k; i++) if (!H[i].Empty()) {// 铁轨i 不为空 x = H[i].rear->data; if (c > x && x > BestLast) { // 铁轨i 尾部的车厢编号较大 BestLast = x; BestTrack = i; } } else // 铁轨i 为空 if (!BestTrack) BestTrack = i; if (!BestTrack) return false; // 没有可用的铁轨 // 把c 移动到最优铁轨 H [BestTrack ] . EnQueue ( c ) ; cout << "Move car " << c << " from input " << "to holding track " << BestTrack << endl; // 如果有必要，则修改m i n H和m i n Q if (c < minH) { minH = c; minQ = BestTrack ; } return true; } bool Railroad(int p[], int n, int k) {// k 个缓冲铁轨，车厢初始排序为p [ 1 : n ] // 如果重排成功，返回t r u e，否则返回false // 如果内存不足，则引发异常NoMem 。 //创建与缓冲铁轨对应的堆栈 LinkQueue<int> *H; H = new LinkQueue<int> [k + 1]; int NowOut = 1; //下一次要输出的车厢 int minH = n+1; //缓冲铁轨中编号最小的车厢 int minS; //minH号车厢对应的缓冲铁轨 //车厢重排 for (int i = 0; i < n; i++) if (p[i] == NowOut) {// 直接输出t cout << "Move car " << p[i] << " from input to output" << endl; NowOut++ ; //从缓冲铁轨中输出 while (minH == NowOut) { Output(minH, minS, H, k, n); NowOut++ ; } } else {// 将p[i] 送入某个缓冲铁轨 if (!Hold(p[i], minH, minS, H, k)) return false; } return true; } void main() { //int p[9]={3,6,9,2,4,7,1,8,5},i=9,j=3; int p[N],i,j; cout<<"火车总数i和缓冲轨数j"<<endl; cin>>i>>j; cout<<"输入火车进轨的顺序"<<endl; for(int k=0;k<i;k++) cin>>p[k]; Railroad(p,i,j); }