火車隊列演算法

① 寫出隊列的入隊及出隊演算法

入隊演算法
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); }