数据结构停车场管理实验报告C

合集下载

数据结构 停车场管理 C++实现

数据结构 停车场管理 C++实现

实验报告一、实验目的1.掌握栈的数据类型描述及栈的特点。

2.掌握栈的顺序和链式两种存储结构的特点及算法描述。

3.掌握五种基本运算及算法在两种不同存储结构上的实现。

4.掌握队列的数据类型描述及链式存储结构的特点和算法描述。

5.掌握队列的五种基本运算及在链式存储结构上的实现。

二、实验内容停车场管理。

设有一个可以停放n辆汽车的狭长停车场(先进后出),它直有一个大门可以供车辆进出。

车辆按到停车场的时间先后依次从停车场最里面向大门口处停放(最先到达的第一辆车放在停车场的最里面)。

如果停车场已经放满n辆车,则后来的车辆只能在停车场大门外的便道上等待,一旦停车场内有车离开,则排在便道上的第一辆车就可以进入停车场。

停车场若有其它车辆要离开,在它之后进入停车场的车必须先退出停车场为它让路,待其车开出停车场后,这些车在按原来的次序进停车场。

每辆车在离开停车场时,都应该根据它在停车场内停留的时间长短交费。

如果停留在便道上的车没进停车场就要离开,允许其离开,不收停车费,并且仍然保持在便道上的车辆次序。

试编程模拟停车场管理。

三、实验与算法分析可以将停车场定义为一个顺序栈s1,便道定义为一个链队列q,而停车场中的某个车辆要离开,则在它后面进入停车场的车必须让道,让其离开,故还必须有一个临时的顺序栈s2,存放让道的车辆。

当有车辆进停车场时,直接进入s1栈,若s1栈满,则进入便道(链队列q)。

若有s1中车辆x离开时,先让在x后面进栈的车从s1退栈,并进栈到s2中,让x离开并收取停车费,然后,再把s2中的所有元素退栈并重新进栈s1,最后,将链队列q的队头元素进栈到s1中,并删除队头元素。

若有链队列q(便道)中的元素y离开时,从链队列中删除该元素即可,不收停车费。

车辆的数据可以表示为(车辆编号,到达/离开时间)。

根据问题要求,在停车场内选择栈结构,来管理车辆,这样可以满足题目要求,让车辆先进后出。

停车位满后,停在便道上的车辆用队列这种结构,可以先来先进停车场。

数据结构用c语言实现停车场管理系统报告书

数据结构用c语言实现停车场管理系统报告书

课程设计任务书学生姓名:专业班级:软件2101(计算2101)指导教师:黄启荃钱小红工作单位:华夏学院计算机教研室设计题目:用C语言实现停车场管理程序的设计初始条件:1、栈与队列的建立和操作.2、带T C或V C的计算机系统。

要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)主要任务:(在规定的时间内完成下列任务)设有一个停放n辆车的狭长停车场,它只有一个大门供车辆出入。

车辆按到达停车场时间的早晚依次从停车场最里面向大门处停放。

若已放满n辆车,则后来的车只能停在外面等待,当有车开走后方依次进入,停在场内的车按时计费。

编制一个程序模拟该停车场管理。

1.汽车的模拟输入信息格式可设为:汽车牌照号码,到达/离去时刻如(‘a’,1,5)为1号车在5时刻到达,(‘b’,5,20)为5号车在20这个时刻离去2. 要求程序输出每辆车到达后的停车位置,以及离开停车场时应缴纳的费用及停留时间。

3.编制完成上述问题的C语言程序、进行程序调试并能得出正确的运行结果,并对采用的算法进行分析。

设计报告撰写格式要求:(课程设计报告按统一通用格式书写)具体内容如下:①设计任务与要求②总体方案与说明③程序主要模块的流程图④源程序清单与注释⑤问题分析与解决方案(包括调试记录、调试报告,即在调试过程中遇到的主要问题、解决方法及改进设想);⑥小结与体会附录:①源程序(必须有简单注释)②使用说明③参考资料时间安排:6月20日---24日第一天布置题目,确定任务、查找相关资料第二天~第四天功能分析,编写程序,调试程序、运行系统;第五天程序验收、答辩;撰写设计报告。

指导教师签字:2011年6月20日系主任签字:年月日设计题目:用C语言实现停车场管理程序的设计1、问题描述即要求停车场是一个可停放n辆汽车的狭长通道,并只有一个大门可供汽车进出,汽车在停车场内按车辆到达的先后顺序,依次由北向南排列(大门在最南端,最先到达的第一辆车停放在车场的最北端),如车长内已停满n辆汽车,则后来的汽车只能在门外的便道上等候,一旦有车开走,则排在便道上的第一辆车即可开入;当停车场内某辆车要离开时,在它后进入的车辆必须先退出车场为它让路,待该辆车开出大门外,其它车辆再按原次序进入车场,每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用,以栈模拟停车场,以队列模拟车场外的便道,按照从终端读入的输入数据序列进行模拟管理.每一组输入数据包括三个数据项:汽车”到达”或”离去”信息,汽车牌照号码以及到达或离去的时刻(到达或离去的时刻也可用计算机控制).对每一组输入数据进行操作后的输入信息为:如是车辆到达,则输入汽车在停车场内或便道上的停留位置;如是车辆离去,则输入汽车在停车场内停留的时间和应交的费用。

C++数据结构停车场管理

C++数据结构停车场管理

数据结构实验报告实验题目:停车场管理学生姓名:班级:学号:问题描述设有一个停车场,它是利用一个南北向的狭窄通道建成,北端封闭,大门在最南端。

最先到达的汽车停放在最北端,后面到达的汽车从北至南依次顺序停放。

停车场只能停放n 辆汽车。

当停车场停满n辆车后,后面到达的汽车只能在门外的便道上等候。

一旦有汽车开走,便道上等候的第一辆车就可以开入停车场停放。

当停车场内某辆汽车要离开时,在它之后进入的车辆必须先退出停车场为它让路,待该车开出大门外,其他汽车再按原次序返回车场。

每辆停放在车场内的汽车在离开时必须按它停放时间的长短交纳费用。

例题分析每到达一辆汽车,先检查停车场栈是否已满,若未满则该车进入停车场停放(入栈操作),并将该车的车号和停放时刻记录在停车场栈的相应元素中,同时显示该车在停车场内的停放位置。

反之,若停车场已满,则该车排到便道上等候的汽车队列最后(入队列操作),并将该车的车号信息记录在汽车队列的相应结点内,同时显示该车在便道上的停放位置。

若要取一辆汽车,则需依次进行下述操作:将阻挡在它后面的汽车退出(停车场栈的出栈操作),并将这些汽车临时存放在另一个辅助栈中(辅助栈的入栈操作);开走要取的汽车(停车场栈的出栈操作),并显示该车应交纳的费用;依次从辅助栈中开出汽车(辅助栈出栈操作),开回停车场中(停车场栈的入栈操作);这时停车场已有一个空车位,便道上等候的第一辆汽车则可以开进停车场内停放(汽车队列的出队列操作和停车场栈的入栈操作)。

程序源代码#include<iostream>#include<conio.h>#include<iomanip>#include<fstream>#include<string>#include <stdlib.h>#include <windows.h>using namespace std;#define Max_Size 2//停车的最大容量#define HourFare 2 //每小时的停车费用int CountForStack=0; //栈里现有的车数int CountForQueue=0; //排队等候的车数typedef struct{char Condition;//到达或者离开的状态int Arrivetime;//到达时间,默认为-1,表示没有到达int Leavetime;//离开时间,默认为-1,表示没有离开int License;//车牌号}CarNode;//保存每辆车的信息typedef struct//栈的定义{CarNode *base;//栈底指针CarNode *top;//栈顶指针int Stacksize;//栈的最大容量}CarStack;typedef struct QNode{char Condition;//到达或者离开的状态int Arrivetime;//到达时间,默认为-1,表示没有到达int Leavetime;//离开时间,默认为-1,表示没有离开int License;//车牌号QNode *next;}QNode;typedef struct//队列的定义QNode *front;//对头指针QNode * rear;//队尾指针}Queue;bool InitStack(CarStack &S1)//初始化栈S1{S1.base=(CarNode*)malloc(Max_Size*sizeof(CarNode));if(!S1.base){cout<<"栈S1 内存分配失败"<<endl;return false;}S1.top=S1.base;S1.Stacksize=Max_Size;return true;}bool InitQueue(Queue &Q){Q.front=(QNode*)malloc(sizeof(QNode));if(!Q.front){cout<<"队列Q 内存分配失败!"<<endl;return false;}Q.rear=Q.front;Q.front->next=NULL;return true;}bool EnQueue(Queue &Q,QNode &e)//插入元素e 为Q 的新的队尾元素QNode *p=(QNode *)malloc(sizeof(QNode));if(!p){cout<<"p 内存分配失败"<<endl;return false;}p->Arrivetime=e.Arrivetime;p->Leavetime=e.Leavetime;p->Condition=e.Condition;p->License=e.License;//将e 赋给Pp->next=NULL;Q.rear->next=p;Q.rear=p;return true;}bool DeQueue(Queue &Q,QNode &t)//出队列函数{if(Q.front==Q.rear){cout<<"队列为空!"<<endl;return false;}QNode *p=Q.front->next;t.Arrivetime=p->Arrivetime;t.Condition=p->Condition;t.Leavetime=p->Leavetime;t.License=p->License;Q.front->next=p->next;if(Q.rear==p)Q.rear=Q.front;}free(p);return true;}void InitCarNode(CarNode &C,char condition,int arrivetime,int leavetime,int license) {C.Arrivetime=arrivetime;C.Condition=condition;C.Leavetime=leavetime;C.License=license;}bool Push(CarStack &S1,CarNode &car)//插入新的元素car 为的栈顶元素{if(S1.top-S1.base>=S1.Stacksize){cout<<"此栈已满,不能压入新的信息"<<endl;return false;}(*S1.top).Arrivetime=car.Arrivetime;(*S1.top).Condition=car.Condition;(*S1.top).Leavetime=car.Leavetime;(*S1.top).License=car.License;++S1.top;//栈顶指针上移return true;}bool Pop(CarStack &S1,CarNode &t)//出栈操作{if(S1.top==S1.base)cout<<"栈S1 为空,不能执行出栈操作"<<endl;return false;}--S1.top;//栈顶指针下移t.Arrivetime=(*S1.top).Arrivetime;t.Condition=(*S1.top).Condition;t.Leavetime=(*S1.top).Leavetime;t.License=(*S1.top).License;return true;}bool IsStackFull(CarStack &S1)//判断S1 栈是否已满{if(S1.top-S1.base>=S1.Stacksize)return true;elsereturn false;}bool IsStackEmpty(CarStack &S1)//判断S1 栈是否已空{if(S1.top==S1.base)return true;elsereturn false;}bool IsQueueEmpty(Queue &Q)//判断队列是否为空{if(Q.front==Q.rear)return true;elsereturn false;}bool SearchInStack(CarStack &S1,int a)//a 表示要查找的车牌号,如果在停车场里面,就返回true{bool tag=false;if(!IsStackEmpty(S1))//如果栈S1 非空{CarNode *p=S1.top-1;while(p!=S1.base){if((*p).License==a)tag=true;--p;}if((*p).License==a)tag=true;}return tag;}bool SearchInQueue(Queue &Q,int a)//a 表示要查找的车牌号,如果在通道里面,就返回true{bool tag=false;if(!IsQueueEmpty(Q))//如果队列非空{QNode *p=Q.front->next;while(p!=Q.rear){if((*p).License ==a)tag=true;p=p->next;}//退出此while 循环时p 指向最后一个元素if((*p).License ==a)tag=true;}return tag;}void InCar(CarStack &S1,Queue &Q,int a1,int a2)//表示进入车辆,a1 表示到达时间,a2 表示车牌号码{if(SearchInStack(S1,a2)){cout<<"车号"<<a2<<"已经存在于停车场内,输入有误"<<endl;return;}if(SearchInQueue(Q,a2)){cout<<"车号"<<a2<<"已经存在于通道内,输入有误"<<endl;return;}if(IsStackFull(S1))//如果堆栈已满,说明停车场已满,需要停车在通道里面{QNode qnode;qnode.Arrivetime=-1;//在通道里面不收费,所以不计时qnode.Condition='A';qnode.Leavetime=-1;//定义为-1,说明还没有开始离开qnode.License=a2;EnQueue(Q,qnode);//停在通道上++CountForQueue;cout<<"车号:"<<qnode.License<<"停在通道的第"<<CountForQueue<<"号位置"<<endl;}else{CarNode carnode;carnode.Arrivetime=a1;carnode.Condition='A';carnode.Leavetime=-1;carnode.License=a2;Push(S1,carnode);++CountForStack;cout<<"车号:"<<carnode.License<<",到达时间:"<<carnode.Arrivetime<<" 点,停在停车场的第"<<CountForStack<<"号位置"<<endl;}}void Sreach(CarStack &S1,Queue &Q,int a){if(SearchInStack(S1,a)){cout<<"车号:"<<a<<"已存在停车场里面的第"<<CountForStack<<"号位置"<<endl;return;}if(SearchInQueue(Q,a)){cout<<"停车场已满,车号"<<a<<"存在于通道里面的第"<<CountForQueue<<"号位置,在次等候"<<endl;return;}else{cout<<"对不起!你查找的车号不在停车场里面"<<endl;return;}}void OutCar(CarStack &S1,Queue &Q,int a1,int a2)//出车函数,a1 表示离开时间,a2 表示车牌号码{if(SearchInQueue(Q,a2)){cout<<"车号"<<a2<<"存在于通道里面,还没有进入停车场,不能离开"<<endl;return;}if(!SearchInStack(S1,a2)){cout<<"车号"<<a2<<"该车不在停车场内"<<endl;return;}CarStack tempstack;InitStack(tempstack);//新建一个栈,存放让路的汽车bool tag1=false;//标志这个停车场出车以前是否已满,默认为没有满tag1=IsStackFull(S1);bool tag2=true;//标志通道是否有汽车在等待,默认为通道为空tag2=IsQueueEmpty(Q); CarNode temp;//用来保存暂时取出的汽车bool tag3=false;while(1){Pop(S1,temp);if(temp.License==a2){if(a1<temp.Arrivetime){cout<<"离开失败!"<<endl;tag3=true;Push(tempstack,temp);}else{cout<<"车号:"<<a2<<"现在离开停车场,所用时间为:"<<a1-temp.Arrivetime<<"小时,应收RMB 为:"<<(a1-temp.Arrivetime)*HourFare<<"元"<<endl;}break;}elsePush(tempstack,temp);//进入暂存栈} 则把前面倒出的车再次放while(!IsStackEmpty(tempstack))//如果临时栈不空,入停车场{Pop(tempstack,temp);Push(S1,temp);}QNode tempqnode;//用来暂时保存从通道出来的汽车if(tag1==true&&tag2==false&&tag3==false)//如果出车前停车场已满,并且通道不为空,并且离开没有失败{DeQueue(Q,tempqnode);--CountForQueue;temp.Arrivetime=a1;temp.Condition=tempqnode.Condition;temp.Leavetime=tempqnode.Leavetime;temp.License=tempqnode.License;Push(S1,temp);}if(tag3==false)//如果停车通道是空的,停车场没有满,并且离开成功{--CountForStack;}}}void showmenu(CarStack &S1,Queue &Q){cout<<"******************************选择菜单*******************************"<<endl;cout<<" 1: 停车"<<endl;cout<<" 2: 离开停车场"<<endl;cout<<" 3: 查看车辆信息"<<endl;cout<<" 4: 退出系统"<<endl;cout<<"*****************************请按键选择******************************"<<endl;int tag;cin>>tag;while(tag!=1&&tag!=2&&tag!=3&&tag!=4)cin>>tag;int a1;unsigned int a2;switch(tag){case 1:cout<<"请输入到达的车号:"<<endl;cin>>a1;cout<<"请输入到达的时间:"<<endl;cin>>a2;InCar(S1,Q,a2,a1);Sreach(S1,Q,a1);break;case 2:cout<<"请输入离开的车号:"<<endl; cin>>a1;cout<<"请输入离开的时间:"<<endl; cin>>a2;OutCar(S1,Q,a2,a1);break;case 3:cout<<"请输入你要查看的车号:"<<endl;cin>>a1;Sreach(S1,Q,a1);break;case 4:return;break;}showmenu(S1,Q);}void main(){CarStack carstack;InitStack(carstack);//建立并且初始化用于停车场的堆栈Queue carQueue;InitQueue(carQueue);//建立并且初始化用于通道的队列showmenu(carstack,carQueue);}。

C语言停车场管理实验报告

C语言停车场管理实验报告

设停车场内只有一个可停放n辆汽车的狭长通道,且只有一个大门可供汽车进出。

汽车在停车场内按车辆到达时间的先后顺序,依次由北向南排列(大门在最南端,最先到达的第一辆车停放在车场的最北端),若车场内已停满n辆汽车,则后来的汽车只能在门外的便道上等候,一旦有车开走,则排在便道上的第一辆车即可开入;当停车场内某辆车要离开时,在它之后开入的车辆必须先退出车场为它让路,待该辆车开出大门外,其它车辆再按原次序进入车场,每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。

试为停车场编制按上述要求进行管理的模拟程序。

功能描述以栈模拟停车场,以队列模拟车场外的便道,按照从终端读入的输入数据序列进行模拟管理。

每一组输入数据包括三个数据项:汽车“到达”或“离去”信息、汽车牌照号码及到达或离去的时刻,对每一组输入数据进行操作后的输出数据为:若是车辆到达,则输出汽车在停车场内或便道上的停车位置;若是车离去;则输出汽车在停车场内停留的时间和应交纳的费用(在便道上停留的时间不收费)。

栈以顺序结构实现,队列以链表实现系统设计及实现1.头文件及宏定义#include <conio.h>#include <malloc.h>#include <stdio.h>#include <stdlib.h>#include <windows.h>#define ClearScreen() system( "cls" ) // 清空当前屏幕#define setcolor() system("color 2f")//设置背景前景颜色#define Pause( szPrompt ) printf( "%s", szPrompt ),getch()2.时间和汽车信息结构体的定义(部分代码)typedef struct carinformation // 车辆信息{char szRegistrationMark[64]; // 车牌号char szArrivalTime[16]; // 到达时间char szEntranceTime[16]; // 进入停车场(开始计费)时间char szDepartureTime[16]; // 离开时间} TCARINFORMATION, *LPTCARINFORMATION;3.栈和队列的定义(部分代码)typedef struct carqueue // 链队{LPTCARNODE lpHead; // 头结点LPTCARNODE lpRear; // 指向当前队尾的指针int nEffectiveSize; // 当前队中元素个数} TCARQUEUE, *LPTCARQUEUE;4.栈和队列的初始化(部分代码)void InitQueue( LPTCARQUEUE &lpCarQueue ){lpCarQueue = ( LPTCARQUEUE ) malloc( sizeof( TCARQUEUE ) );lpCarQueue->lpHead = ( LPTCARNODE) malloc( sizeof( TCARNODE ) );lpCarQueue->lpHead->lpNext = NULL;lpCarQueue->lpRear = lpCarQueue->lpHead;lpCarQueue->nEffectiveSize = 0;}实现过程1.开始界面:输入车库容量2.输入车辆到达信息3.当车库停满车时临时停到便道上不收车费4.车辆离开后车库有车位便道上的车进入车库并显示离去车的收费记录5.显示车库及便道信息6.停止输入显示制作者信息及退出程序实训心得通过这次实训我对课本上的理论知识有了更深层次的了解,可能在仅一周的时间内学到的东西有限,不过却也是受益非浅,实训本来就是对平常所学的理论知识通过具体的实现表示出来是在完成理论课程学习之后安排的综合实践训练,任何一个优秀的程序员都是从实践中获得经验和教训的。

数据结构停车场管理完整版实习报告

数据结构停车场管理完整版实习报告

实习报告题目:停车场管理一.需求分析1.用栈来表示停车场,用队列来表示停车道。

2.用户需输入车辆的必要信息,如车辆的到达或离开,汽车牌号以及到达或离去的时刻。

停车场的容量及单位时间的停车费由编程序者自行设置,结构需输出车辆停车所需缴纳的费用。

3.本程序要求对车辆的动态能够输出具体的信息内容,包括停车或离开的时间,位置,及所需缴纳的停车费。

4.测试数据为:2,输入数据为:(’A’,1,5),(‘A’,2.,10), (‘D’,1,15), (‘A’,3,20), (‘A’,4,25), (‘A’,5,30),(‘D’,2,35), (‘D’,4,40), (‘E’,0,0). 其中:’A’表示到达,’D’表示离去,’E’表示输入结束。

5.程序执行的命令为:1.创建栈和队列。

2.对车辆的行为进行相应的处理。

3.输出车辆的信息。

二.概要设计1.设定栈的抽象数据类型定义:{数据对象:{属于1,2……, n>=0}数据关系:R1={<1, >| 1属于D,2,……,n}基本操作:()操作结果:构造一个空栈S.()初始条件:栈S已存在。

操作结果:删除S的栈顶元素,并以e返回其值。

( )初始条件:栈S已存在。

操作结果:在栈S的栈顶插入新的栈顶元素e。

(S)初始条件:栈S已存在。

操作结果:返回S中的元素个数,即栈的长度。

} ;2.设定队列的抽象数据类型定义:{数据对象:{ 属于, 1,2,……,n, n>=0}数据关系:R1={<1 >| 1 属于D,2,……}基本操作:()操作结果:构造一个空队列Q.(, e)初始条件:队列Q已存在。

操作结果:插入元素e为Q的新的队尾元素。

(, )初始条件:Q为非空队列。

操作结果:删除Q的对头元素,并用e返回其值。

(Q)初始条件:队列Q已存在。

操作结果:返回Q的元素个数,即队列的长度。

}3.本程序主要包括三个模块1.主程序模块;(){初始化;{接受命令;处理命令;}(命令!=退出);}2.处理车辆到达模块;3.处理车辆离开模块;各模块之间的调用关系如下:处理车辆到达模块←主程序模块→处理车辆离开模块三.详细设计设计程序如下:<>n 2将停车场的容量设为2;10将单位时间的停车费设为10,车道里不收费;-2分配栈的存储空间失败;;{定义元素数据结构类型;;};{队列*;;},*;{队头指针队尾指针};( ){构造一个空队列()(());()();>>;}( ){入队操作()(());>;>;>;>;;}( Q){0;p;>;(){;>;};i;}( ){从对头离队操作,并返回其值()(());()<<"车道中没有车辆!"<<; (){>;>;>>;() ;(p);}}{*;*;;};( ){创建一个空栈(*)(n*());() ();;;}( )插入新的元素{*;()1;{;>;>;;0;}}( S){当前栈的长度;}( ) {删除栈顶元素,并返回其值() ;*;1;}( ){0输入数据正确r;*;;()/在栈中寻找是否有同一编号的车;{(>){<<"该车号在停车场中已存在,请重新输入!"<<;1找到了有同一编号的车;};}(0){在栈中未找到,从队列中查找>; 队头(>){>;}(>) {<<"该车号在车道中已存在,请重新输入!"<<1;} }(0)说明经检查输入数据正确;{()说明栈未满,{>;>;;<<"请进入停车场"<<(S)<<"号车位!"<<;}{();<<"请便车道"<<(Q)<<"稍等!"<<;}}}( ){0在栈中没有找到与要离开的车,*;;;(0){()先在栈中寻找;{(>){;(>)*;1在栈中找到<<"您的停车时间为"<<><<"小时,请交纳费用!"<<<<;;};}(1) 备用栈{;();(1)先在栈中寻找;{();();}(S,*);(){(){();();}}}(1)栈中有车离开,将队列中的车进入栈中{(); 离队,并返回数据e>;>;;<<<<"请便道的第一辆车"<<"牌号是:"<<<<"转入停车场,停车起始时刻是:"<<<<"!"<<" 停车位置为"<<(S)<<"号!"<<;}}(0)栈中没找到要离开的车{;>; 队头(>){;>;}(>)2; 在队列中找到要离开的车(>){2;<<"便道"<<><<"号车离开,不收取费用!"<<;>>;(r);}}直接从队列离开(0)<<"没有该辆车!"<<;}(){c;010,判断临时记录时间的应该去该次的值,还是上次的值。

数据结构停车场管理实验报告

数据结构停车场管理实验报告

数据结构停车场管理实验报告一、实验目的本次实验旨在通过设计和实现一个停车场管理系统,深入理解和应用数据结构中的栈和队列等知识,提高解决实际问题的能力。

二、实验环境编程语言:C++开发工具:Visual Studio三、实验原理1、停车场采用栈结构来存储停放的车辆信息。

栈具有先进后出的特点,符合车辆先进入停车场后离开的逻辑。

2、停车场外的便道采用队列结构来存储等待进入停车场的车辆。

队列具有先进先出的特点,符合车辆按到达顺序进入停车场的需求。

四、实验内容1、设计数据结构定义栈和队列的数据结构,包括存储车辆信息的结构体。

实现栈和队列的基本操作,如入栈、出栈、入队、出队等。

2、功能实现车辆进入停车场:当有车辆进入停车场时,将车辆信息压入栈中。

车辆离开停车场:当有车辆离开停车场时,从栈中弹出相应车辆,并计算停车费用。

显示停车场状态:实时显示停车场内车辆的信息。

处理便道上的车辆:当停车场有空位时,将便道上的车辆依次入停车场。

3、界面设计设计简单的命令行交互界面,方便用户输入操作指令。

五、实验步骤1、定义数据结构```cppstruct Car {int carNumber;int arrivalTime;int departureTime;};class Stack {private:Car stackArray;int top;int capacity;public:Stack(int size) {capacity = size;stackArray = new Carcapacity; top =-1;}~Stack(){delete stackArray;}bool isFull(){return top == capacity 1;}bool isEmpty(){return top ==-1;}void push(Car car) {if (!isFull()){stackArray++top = car;} else {std::cout <<"停车场已满,无法进入!"<< std::endl;}}Car pop(){if (!isEmpty()){return stackArraytop;} else {std::cout <<"停车场为空,无法离开!"<< std::endl; return {-1, -1, -1};}}Car peek(){if (!isEmpty()){return stackArraytop;} else {std::cout <<"停车场为空!"<< std::endl; return {-1, -1, -1};}}};class Queue {private:Car queueArray;int front;int rear;int capacity;public:Queue(int size) {capacity = size;queueArray = new Carcapacity;front = rear =-1;}~Queue(){delete queueArray;}bool isFull(){return (rear + 1) % capacity == front;}bool isEmpty(){return front ==-1;}void enqueue(Car car) {if (!isFull()){if (isEmpty()){front = 0;}rear =(rear + 1) % capacity; queueArrayrear = car;} else {std::cout <<"便道已满,无法等待!"<< std::endl;}}Car dequeue(){if (!isEmpty()){Car car = queueArrayfront;if (front == rear) {front = rear =-1;} else {front =(front + 1) % capacity;}return car;} else {std::cout <<"便道为空!"<< std::endl;return {-1, -1, -1};}}Car frontElement(){if (!isEmpty()){return queueArrayfront;} else {std::cout <<"便道为空!"<< std::endl;return {-1, -1, -1};}}};```2、主函数实现```cppint main(){int parkingLotCapacity = 10; //假设停车场容量为 10 Stack parkingLot(parkingLotCapacity);Queue waitingQueue(parkingLotCapacity);int choice;while (true) {std::cout <<"1、车辆进入停车场" << std::endl;std::cout <<"2、车辆离开停车场" << std::endl;std::cout <<"3、显示停车场状态" << std::endl;std::cout <<"4、退出" << std::endl;std::cout <<"请选择操作:";std::cin >> choice;switch (choice) {case 1: {int carNumber;std::cout <<"请输入车辆号码:";std::cin >> carNumber;Car car ={carNumber, time(NULL),-1};if (!parkingLotisFull()){parkingLotpush(car);std::cout <<"车辆"<< carNumber <<"进入停车场" <<std::endl;} else {waitingQueueenqueue(car);std::cout <<"停车场已满,车辆"<< carNumber <<"在便道等待" << std::endl;}break;}case 2: {int carNumber;std::cout <<"请输入要离开的车辆号码:";std::cin >> carNumber;Car car;bool found = false;for (int i = parkingLottop; i >= 0; i) {if (parkingLotstackArrayicarNumber == carNumber) {car = parkingLotpop();cardepartureTime = time(NULL);found = true;break;}}if (found) {int parkingTime = difftime(cardepartureTime, cararrivalTime);double parkingFee = parkingTime 2; //假设每单位时间停车费为2 元std::cout <<"车辆"<< carNumber <<"离开停车场,停车时间:"<< parkingTime <<"秒,停车费用:"<<parkingFee <<"元" << std::endl;if (!waitingQueueisEmpty()){Car waitingCar = waitingQueuedequeue();parkingLotpush(waitingCar);std::cout <<"便道上的车辆"<< waitingCarcarNumber <<"进入停车场" << std::endl;}} else {std::cout <<"未找到要离开的车辆" << std::endl;}break;}case 3: {std::cout <<"停车场内车辆:"<< std::endl;for (int i = parkingLottop; i >= 0; i) {std::cout << parkingLotstackArrayicarNumber <<"";}std::cout << std::endl;std::cout <<"便道上等待的车辆:"<< std::endl;if (!waitingQueueisEmpty()){for (int i = waitingQueuefront; i!= waitingQueuerear; i =(i + 1) %waitingQueuecapacity) {std::cout << waitingQueuequeueArrayicarNumber <<"";}std::cout << waitingQueuequeueArraywaitingQueuerearcarNumber<< std::endl;} else {std::cout <<"无" << std::endl;}break;}case 4:return 0;default:std::cout <<"无效的选择,请重新输入" << std::endl;}}return 0;}```六、实验结果1、车辆正常进入停车场,并在停车场已满时在便道等待。

数据结构-停车场管理系统实验报告

数据结构-停车场管理系统实验报告

数据结构-停车场管理系统实验报告数据结构停车场管理系统实验报告一、实验目的本次实验旨在通过设计和实现一个停车场管理系统,深入理解和应用数据结构的知识,包括栈、队列、链表等,提高编程能力和解决实际问题的能力。

二、实验环境本次实验使用的编程语言为C++,开发环境为Visual Studio 2019。

三、需求分析1、停车场内有固定数量的停车位。

2、车辆进入停车场时,记录车辆信息(车牌号、进入时间)。

3、车辆离开停车场时,计算停车费用并输出相关信息。

4、能够显示停车场内车辆的停放情况。

四、数据结构设计1、为了实现车辆的先进先出,选择队列来存储停车场内的车辆信息。

2、用栈来存储临时停放的车辆信息,以便在停车场已满时进行处理。

五、算法设计1、车辆进入停车场检查停车场是否已满。

如果未满,将车辆信息加入队列,并记录进入时间。

2、车辆离开停车场在队列中查找要离开的车辆。

计算停车时间和费用。

将车辆从队列中删除。

3、显示停车场内车辆停放情况遍历队列,输出车辆信息。

六、主要代码实现```cppinclude <iostream>include <string>include <ctime>using namespace std;//车辆结构体struct Car {string licensePlate; //车牌号time_t entryTime; //进入时间};//队列类class Queue {private:Car data;int front, rear, capacity;public:Queue(int size) {capacity = size;data = new Carcapacity;front = rear = 0;}~Queue(){delete data;}bool isFull(){return (rear + 1) % capacity == front;}bool isEmpty(){return front == rear;}void enqueue(Car car) {if (isFull()){cout <<"停车场已满!"<< endl; return;}datarear = car;rear =(rear + 1) % capacity;}Car dequeue(){if (isEmpty()){cout <<"停车场为空!"<< endl;return Car();}Car car = datafront;front =(front + 1) % capacity;return car;}void display(){if (isEmpty()){cout <<"停车场内没有车辆。

数据结构实验报告模拟停车场管理

数据结构实验报告模拟停车场管理

数据结构实验报告模拟停车场管理实验目的:通过模拟停车场管理的过程,理解数据结构的应用和实际工程问题的解决思路。

实验内容:1.设计停车场类和车辆类,并实现相关操作方法。

2.模拟停车场管理的过程,包括车辆的进入和离开。

3.根据实际需求设计停车场管理算法,如何选择停车位和调度车辆等。

实验步骤:1.设计停车场类停车场类需要保存停车位的信息,可以使用数组或链表实现。

需要提供以下方法:- void addCar(Car car):将车辆添加到停车场,如果停车场已满,则禁止入场。

- void removeCar(Car car):将车辆从停车场移除,并更新停车位信息。

- int getAvailableSpaces(:返回停车场中当前可用的停车位数量。

2.设计车辆类车辆类需要保存车辆的信息,如车牌号、车型等。

3.实现停车场管理算法停车场管理需要考虑车辆进入和离开的顺序,以及停车位的选择等问题。

可以使用队列或堆栈等数据结构来保存车辆的进出顺序。

停车位的选择可以根据具体算法进行,如先到先得、最近最便等原则。

4.完成模拟停车场管理过程的代码根据实际需求,编写代码模拟车辆进入和离开停车场的过程。

可以通过输入车辆信息和操作指令来模拟。

5.测试与优化对停车场管理算法进行测试,并根据实际情况进行优化。

可以通过增加数据量、调整车辆进出顺序等方式进行测试,并根据测试结果进行优化。

实验结果:经过实验测试,停车场管理系统可以良好地处理车辆的进入和离开,并正确计算可用停车位的数量。

通过合理的停车位选择算法,确保了车辆进出的顺序。

实验总结:通过本次实验,我们学习了如何利用数据结构来实现停车场管理系统。

停车场管理系统是一种常见的实际应用,对于解决停车难问题具有重要意义。

在实验过程中,我们掌握了设计和实现停车场类、车辆类以及停车场管理算法的方法,加深了对数据结构的理解和应用。

在实验过程中,我们还发现停车场管理算法可以通过不同的策略进行优化,如最大化停车利用率、最小化顾客等待时间等。

数据结构用栈和队列创建停车场管理系统实验报告

数据结构用栈和队列创建停车场管理系统实验报告

数据结构用栈和队列创建停车场管理系统实验报告一、实验背景及目的随着城市化进程的不断加速,车辆数量急剧增长,停车难成为了城市发展中的一个重要问题。

为了解决这一问题,需要建立高效的停车场管理系统。

数据结构中的栈和队列是常用的数据结构,可以用来创建停车场管理系统。

本次实验旨在通过使用栈和队列来创建一个停车场管理系统,并测试其功能。

二、实验原理及方法1. 停车场管理系统基本原理停车场管理系统主要包括三个部分:入口、出口和停车位。

当车辆到达入口时,需要检查是否有空余的停车位;如果有,则将其分配一个位置并记录下来;否则,需要让其等待直到有空余位置。

当车辆离开时,需要释放该位置并更新记录。

2. 使用栈和队列创建停车场管理系统(1)使用栈来模拟停车位由于每个停车位只能容纳一辆汽车,可以使用栈来模拟每个停车位。

当有新的汽车进入时,将其压入栈中;当汽车离开时,则将其从栈中弹出。

(2)使用队列来模拟等待区由于等待区可以容纳多辆汽车,可以使用队列来模拟等待区。

当有新的汽车到达时,将其加入队列尾部;当有车位空余时,则从队列头部取出一辆汽车进入停车场。

3. 实验步骤(1)创建停车场管理系统的数据结构:使用栈和队列分别来模拟停车位和等待区。

(2)实现停车场管理系统的基本操作:包括汽车进入、离开、查询空余停车位等操作。

(3)测试停车场管理系统的功能:模拟多辆汽车进出停车场,检查系统是否能够正确地分配和释放停车位,并且能够正确地记录空余停车位数。

三、实验结果与分析本次实验使用栈和队列创建了一个简单的停车场管理系统,并测试了其基本功能。

在测试过程中,我们模拟了多辆汽车进出停车场,并检查了系统能否正确地分配和释放停车位。

实验结果表明,该系统可以正常工作,并且能够正确地记录空余停车位数。

四、实验总结通过本次实验,我们学习了如何使用栈和队列来创建一个简单的停车场管理系统。

同时,我们也深刻认识到数据结构在实际应用中的重要性。

在今后的学习中,我们将继续深入学习数据结构,并探索其更广泛的应用。

停车场管理系统C语言实习报告

停车场管理系统C语言实习报告

停车场管理系统C语言实习报告一、实习背景在城市化进程不断加速的背景下,汽车数量急剧增长,停车难的问题日益突出,停车场管理系统成为解决这一问题的重要途径。

为了更好地了解和掌握停车场管理系统的开发过程和实现方法,我选择了该方向作为我的实习内容。

二、实习过程在实习过程中,我主要参与了停车场管理系统的需求分析、模块设计和编码实现等工作。

1.需求分析首先,我对停车场管理系统的需求进行了详细地分析和理解。

通过与公司内部相关人员的交流和讨论,我了解到停车场管理系统主要包括车辆信息管理、停车记录管理和收费管理等功能。

2.模块设计在需求分析的基础上,我开始进行停车场管理系统的模块设计工作。

根据需求,我划分出了车辆信息管理模块、停车记录管理模块和收费管理模块等多个模块。

然后,我详细地设计了这些模块的功能和数据流程,并与其他开发人员进行了交流和讨论。

3.编码实现在模块设计完成后,我开始进行停车场管理系统的编码实现工作。

首先,我选择了C语言作为开发语言,并使用了相关的开发工具。

然后,我按照设计的流程和规范进行了编码工作,并通过反复调试和测试,最终实现了一个具有基本功能的停车场管理系统。

三、实习收获通过这次实习,我对停车场管理系统的开发和实现过程有了更深入的了解和掌握。

首先,我学会了如何进行需求分析和模块设计,并将其应用于实际开发中。

其次,我通过实际编码实现了停车场管理系统,并通过调试和测试不断完善和优化。

最后,我还与其他开发人员进行了紧密的合作和协调,提高了我与他人沟通和协作的能力。

四、总结与展望通过这次实习,我对停车场管理系统有了全面的认识和了解,并学会了如何进行开发和实现。

但是,在实际工作中还存在一些不足之处,比如对一些技术的了解不够深入和对一些问题的解决不够完善。

因此,我希望今后能够进一步加强相关技术的学习和研究,提高自己的综合能力和解决问题的能力。

在未来的工作中,我将继续深入研究和学习停车场管理系统的相关技术,并通过不断地实践和探索,提高自己的专业能力和水平。

c++数据结构,停车场系统 实验报告

c++数据结构,停车场系统  实验报告

HDU 软件工程学院《程序设计实践(下)》设计报告姓名学号专业班级10级软件工程6班提交日期成绩指导教师问题解析(对问题的分析、解题思路与解题方法)题目一: 停车场管理系统[实验目的]综合运用线性表、队列、排序、随机数等数据结构知识,掌握并提高分析、设计、实现及测试程序的综合能力。

[实验内容及要求]停车场拥有M个车位和一条进入停车场的便道,便道上最多停放N辆汽车。

汽车要想进入车位,首先进入便道等候。

若有空闲车位,则停车入位,否则在便道继续等候,直至有车位空出。

若便道已经停满等候的汽车,后到达的汽车只能离开,选择其他停车场。

设计一个停车场管理系统,模拟停车场的运作,并统计停车场的收入。

(1)使用随机数产生某一时间段内进入和离开停车场的车辆数目;(2)存储并记录如下数据项:汽车到达和离去的时间及汽车的车号;(3)车辆到达时,提示汽车的停车位置编号(为车辆分配编号最小的可用车位),若车位已满给出相应提示;(4)汽车离去时,输出汽车在停车场内停留的时间和应交纳的费用。

(5)对该停车场进行统计:统计每天到达、离开的车次,停车总时数、每天停车场的收入等。

[问题分析]停车场系统,可以利用之前写过的队列,链表,排序等知识实现模拟,可以手工输入车的牌号和进入时间,但是这样可能给测试人员带来一定的麻烦,我们可以利用随机数字定义一个数组来实现车牌的分配和时间的分配,车牌利用五位数来简单模拟,前两位用英文字母后三位用数字,这样分配的车牌有26*26*10*10*10=676000种可能,所以不用检查车牌号是否相同,这样就节省了很多用来查找的时间。

[解决思路]1、可以用队列模拟便道,利用入队列,出队列完成车辆的进入和离开的模拟。

题目要求,进入便道不计费,可以仅仅记录车牌来实现2、可用车位需按照编号排序,申请车位时分配编号最小的车位,可用车位动态变化,可以选择利用堆排序来实现,当出来一个车的时候,3、利用rand()随机产生随机数,来完成每小时进入车场的车辆和离开的车辆,对于车辆一小时离开的概率为25%,增加一小时离开的概率多加25%,可以用累加的形式,当车辆进入的时候,就分配给车辆一个参数,这个参数用来实现车辆在车场中的停留时间的记录4、车场刚开始,初始化的时候,就按顺序分配一些车场位置编号,用来记录与车牌对应的位置,停车场还有个参数,用来记录,此位置是否有车,如果有车就设置为true,如果没车就为false,用来统计车场中的车辆5、统计离开的车辆,当车辆离开的时候,就把参数设置为false[任务分工及进度计划]12月10号上午八点半-12月10中午完成类的设计,以及设计思路12月10号下午-12月11号全天完成类的实现12月11号-12月13号中间的空闲时间完成界面的美化和测试12月17号晚上-12月18号完成哈弗曼译码的设计和实现,由于之前这个程序已经写过,设计和编写都节省了很多时间12月19号-12月20号完成实验报告[数据结构选择、算法设计(伪代码,算法思想)]数据结构中设计到的算法有:1.队列2、链表(用结构体代替)--------------------------------------------主体函数---------------------------------------------#include <cstdlib>#include <iostream>#include "Car.h"#include "SeqQueue.h"#include"Park.h"#include <windows.h>#include <ctime>----------------------------------------------------------------------------------------------class Car{private:string chepai;string jinru_time;string likai_time;double begin;double end;double cost_money;public:Car();void shuruchepai(string );void jinru(string );void likai(string );void cost(double cost);double huafei();string getchepai()string getjinru()string getlikai()};--------------------------------------------------------------------------------------------emplate<class T>class SeqQueue{private:int front,rear;T *elem;int size;int len;public:SeqQueue(int size);~SeqQueue();bool IsEmpty();void enqueue(T x);T dequeue();int num();};-------------------------------------------------------------------------------------------------class Park{private:string chepai;string jinru_time;char likai_time[9];string likai2;double begin;double end;double cost_money;bool isempty;int stay_time;int times_likai;int weizhihaoma;double sum_money;public:Park(){ isempty=false;stay_time=0;times_likai=0;sum_money=0;}void shuruchepai(string a)void jinru(string a)-void weizhi(int a)void haha(string a)string gethaha()void sum_money1(double a)double money1()void likai(int k)void cost(double cost)double huafei()string getchepai()string getjinru()char* getlikai()void run()int getweizhihaoma()void setweizhihaoma(int a)void goaway()};---------------------------------------------------------------------------------------------class Che{public:Che();void ShuRuChePai(string);//输入车牌void JinRu(string);//输入车进入停车场的时间void LiKai(string);//输入车离开停车场的时间bool Compare(string);double ShuChuM(double);private:string s;//车牌号记录double st;//车到停车场的时间double et;//车离开停车场的时间};//车的类------------------------------------------------------------------------------------------------[测试方法、测试数据与测试结果]测试方法:需要输入停车场的停车位的数量和便道中可以等待的车位的数量,以及每小时停留在停车场中的花费。

C++数据结构停车场管理

C++数据结构停车场管理

C++数据结构停车场管理一、引言本文档旨在介绍C++数据结构停车场管理系统的设计和实现过程。

停车场管理系统是一个用于管理停车场车辆进出、计费等相关功能的软件,可以提高停车场管理的效率和精确度。

二、需求分析⒈功能需求⑴车辆入场管理:记录车辆的入场时间、车牌号等信息。

⑵车辆出场管理:根据车牌号查询车辆的停车时间并计费,同时将车辆从停车场中移除。

⑶停车位管理:实时显示停车场内还有多少空闲停车位。

⑷支付管理:提供支付功能,支持现金、信用卡等多种支付方式。

⑸数据统计:停车场的使用统计报表,包括停车次数、收入等信息。

⒉性能需求⑴系统响应时间应尽可能短,以满足用户快速进出停车场的需求。

⑵数据存储和查询速度应尽可能快,以保证系统的实时性和准确性。

三、系统设计⒈数据结构设计⑴车辆信息:使用结构体保存车辆的信息,包括车牌号、入场时间、离场时间等。

⑵停车位状态:使用数组或链表表示停车位的状态,空闲或占用。

⑶支付记录:使用结构体保存支付的相关信息,包括支付方式、支付时间等。

⒉模块设计⑴车辆入场管理模块:负责记录车辆的入场时间和车牌号,并将车辆信息添加到停车场管理系统中。

⑵车辆出场管理模块:接受用户输入车牌号查询车辆的停车时间并计费,同时将车辆从停车场中移除。

⑶停车位管理模块:实时更新停车位的状态,显示停车场内还有多少空闲停车位。

⑷支付管理模块:提供支付功能,支持现金、信用卡等多种支付方式。

⑸数据统计模块:停车场的使用统计报表,包括停车次数、收入等信息。

四、系统实现⒈系统流程图插入系统流程图⒉模块实现略\t五、测试与验证⒈单元测试:对每个模块进行独立测试,确保其功能的正确性和稳定性。

⒉集成测试:将所有模块整合在一起进行测试,验证系统的功能和性能是否符合需求。

六、部署与维护⒈部署:将停车场管理系统部署到指定的服务器或计算机上,配置相关的数据库和网络连接。

⒉维护:定期检查系统的稳定性和性能表现,及时修复错误和进行系统更新。

七、文档附件本文档涉及附件,请参考附件部分。

数据结构停车场实习报告

数据结构停车场实习报告

一、实习背景随着我国经济的快速发展,城市车辆数量逐年攀升,停车难问题日益突出。

为了解决这一问题,我们需要设计一个高效、便捷的停车场管理系统。

本次实习以数据结构为基础,设计并实现了一个停车场管理系统。

二、实习目的1. 理解并掌握数据结构在实际问题中的应用;2. 提高编程能力和算法设计能力;3. 掌握停车场管理系统的设计与实现方法;4. 分析并解决实际问题。

三、系统设计1. 系统功能(1)车辆进出管理:实现车辆进入和离开停车场的功能,包括记录车辆信息、计算停车费用等。

(2)车位管理:实时显示停车场内剩余车位数量,实现车位分配和回收。

(3)数据统计:统计停车场使用情况,包括车辆进出次数、停车时间等。

(4)异常处理:处理车辆进出异常情况,如超时、非法操作等。

2. 数据结构设计(1)停车场:使用栈结构存储停车场内的车辆信息,栈底为停车场最里面,栈顶为停车场最外面。

(2)便道:使用队列结构存储便道上的车辆信息,队列头为便道最外面,队列尾为便道最里面。

(3)车辆信息:包括车辆牌照、进入时间、离开时间、停车费用等。

3. 算法设计(1)车辆进入停车场:判断停车场是否已满,若不满,则将车辆信息压入栈中;若满,则将车辆信息入队。

(2)车辆离开停车场:判断便道是否为空,若为空,则从栈中弹出车辆信息;若不为空,则从队列中出队车辆信息。

(3)计算停车费用:根据车辆停留时间计算停车费用。

四、实习过程1. 需求分析:了解停车场管理系统的基本需求,确定系统功能。

2. 设计阶段:设计系统架构、数据结构、算法等。

3. 编码阶段:根据设计文档,使用C++语言进行编程实现。

4. 测试阶段:编写测试用例,对系统进行功能测试、性能测试等。

5. 调试阶段:针对测试过程中发现的问题进行调试和优化。

五、实习结果1. 系统功能实现:停车场管理系统已实现车辆进出管理、车位管理、数据统计、异常处理等功能。

2. 数据结构应用:成功将栈和队列应用于停车场管理系统,提高了系统性能。

数据结构停车场管理实验报告C++

数据结构停车场管理实验报告C++

数据结构课程设计题目停车场管理器设计专业:计算机科学与技术班级:1401姓名:彭旭学号:143230135实验主要内容以栈模拟停车场,以队列模拟车场外的便道,按照从终端读入的输入数据序列进行模拟管理。

每一组输入数据包括三个数据项:汽车“达到”或“离去”信息、汽车牌照号码以及达到或离去的时刻。

对每一组输入数据进行操作后的输出信息为:若是车辆达到、则输出汽车在停车场内或便道上停车位置;若是车辆离去,则输出汽车在停车场内停留的时间和应交纳的费用(在便道上停留的时间不收费)。

栈以顺序结构实现,队列以链表结构实现。

环境Windows 10 Visual C++ c 语言实验原理1.概要设计(1 )抽象数据类型定义ADT Stack{数据对象:D={ai|ai € ElemSet, i=1,2,…n;n>0}数据关系:R1={<ai-1,ai>|ai-1,ai € D,i=2,…n}基本操作:Ini tStack(&S)操作结果:构造一个空栈SoPush(&S,e)初始条件:栈S已存在。

操作结果:插入e为新的栈顶元素Pop(&S,&e)初始条件:栈S已存在。

操作结果:删除S的栈顶元素,并且用e返回。

}ADT StackADT Queue {数据对象:D={ai|ai € ElemSet, i=1,2,…n; n>0}数据关系:R1={<ai-1,ai>|ai-1,ai € D, i=2,…n}其中:a1 为队头,an为队尾基本操作:Ini tQueue(&Q);操作结果:构造一个空队列QEn Queue(&Q, &e);初始条件:对列Q已存在。

操作结果:插入元素e为Q的新队尾元素。

DeQueue(&Q, &e);初始条件:对列Q已存在。

操作结果:删除Q的队头元素,并用e返回。

}ADT Queue(2)本程序包含七个模块:<1>主程序模块,其中主函数为Void mai n(){初始化;构造空栈;输入已知数据;插入数据入栈;分析{入栈;出栈;入队;出队;}输出数据;}<2>构造栈模块——构造一个空栈;「构造栈模块][栈插入模块][栈删除模块][构造队列模块][队列插入模块][队列删除模块2.详细设计<1>类型定义#define STACK_INIT_SIZE 100#defi ne STACKINCREMENT 10#defi ne MONE Ytypedef int Status;typedef struct ElemType{char a⑶;int num;int time;}ElemType;typedef struct SqStack {ElemType *base;〃在栈构造之前和销毁之后,base的值为NULLElemType *top;〃栈顶指针int stacksize;//当前已经分配的存储空间,以元素为单位}SqStack;〃栈的表示typedef struct QNode{ElemType data;struct QNode *n ext;}QNode,*QueuePtr;〃队列的表示typedef struct Lin kQueue{QueuePtr fron t;〃队头指针QueuePtr rear;// 队尾指针}Lin kQueue;<2>栈和队列的基本操作Status In itStack(SqStack &S)//构造一个空栈Status Push(SqStack &S,ElemType e)//插入元素e为新的栈顶元素Status Pop(SqStack &S,ElemType &e)//若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK ;否贝V返回ERRORStatus Ini tQueue(L in kQueue &Q)//构造一个空队列QStatus En Queue(L in kQueue &Q,ElemType e)//插入元素e为Q的新队列Status DeQueue(L in kQueue &Q,ElemType &e)//若队列不空,则删除Q的对头元素,用e返回其值,并返回Ok;否则返回ERROR;<3>部分操作的算法Status In itStack(SqStack &S){// 构造一个空栈S.base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));if(!S.base) exit (OVERFLOW);S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status Push(SqStack &S,ElemType e){〃插入元素e 为新的栈顶元素if(S.top-S.base>=S.stacksize){〃栈满,追加存储空间S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(EI emType));if(!S.base) exit(OVERFLOW);// 存储分配失败S.top=S.base+S.stacksize;S.stacksize+=STACK_INIT_SIZE;}*S.top++=e;return OK;}Status Pop(SqStack &S,ElemType &e){//若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK;否则返回ERRORif(S.top==S.base) return OK;e=*--S.top;return OK;}// --------- 队列Status Ini tQueue(Li nkQueue &Q){〃构造一个空队列Q Q.fro nt=Q.rear=(QueuePtr)malloc(sizeof(QNode));if(!Q.fro nt) exit (OVERFLOW);// 存储分配失败Q.fro nt-> next=NULL;return OK;}Status EnQueue(LinkQueue &Q,ElemType e){〃插入元素e 为Q的新队列p=(QueuePtr)malloc(sizeof(QNode));〃存储分配失败if(!p) exit(OVERFLOW);p->data=e;p->n ext=NULL;Q.rear- >n ext=p;Q.rear=p;return OK;}Status DeQueue(L in kQueue &Q,ElemType &e){//若队列不空,则删除Q的对头元素,用e返回其值,并返回Ok; 否则返回ERROR;if(Q.fro nt==Q.rear) return ERROR;p=Q.fr ont->n ext;e=p->data;Q.fro nt->n ext=p->n ext;if(Q.rear==p) Q.rear=Q.fr ont;free(p);return OK;}源程序Stopl.h:#i nclude <stdio.h>#i nclude <process.h>#i nclude <malloc.h>#in clude <stri ng.h>// -------------- 函数结果状态代码#defi ne TRUE 1#defi ne FALSE 0#defi ne OK 1#defi ne ERROR 0#defi ne TNFEASIBLE -1#defi ne OVERFLOW -2//Status 是函数的类型,其值是函数结果状态代码typedef int Status;#defi ne STACK_INIT_SIZE 100#defi ne STACKINCREMENT 10#defi ne MONEY 3Stop2.h:#i nclude"stop1.h"typedef struct ElemType{char a[3];int num;int time;}ElemType;typedef struct SqStack{ElemType *base;ElemType *top;int stacksize;}SqStack;〃栈的表示typedef struct QNode{ElemType data;struct QNode *n ext;}QNode,*QueuePtr;〃队列的表示typedef struct Lin kQueue{QueuePtr fron t;〃队头指针QueuePtr rear;// 队尾指针}Lin kQueue;Status In itStack(SqStack &S);〃构造空栈Status Push(SqStack &S,ElemType e);〃进栈Status Pop(SqStack &S,ElemType &e);〃出栈Status Ini tQueue(L in kQueue &Q);〃构造一个空队列Status En Queue(L in kQueue &Q,ElemType e);〃入队Status DeQueue(Li nkQueue &Q,ElemType &e);〃出队Stop.cpp:#in clude"stop2.h"Status In itStack(SqStack &S){// 构造空栈S.base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType)); if(!S.base) exit(OVERFLOW);S.top=S.base;S.stacksize=STACK_INIT_SIZE;return OK;}Status Push(SqStack &S,ElemType e){// 插入元素 e 为新的栈顶元素if(S.top-S.base>=S.stacksize){〃栈满,追加存储空间S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemType)); if(!S.base)队列*/exit(OVERFLOW);S.top=S.base+S.stacksize;S.stacksize+=STACK_INIT_SIZE;}*S.top++=e;return OK;}Status Pop(SqStack &S,ElemType &e){// 出栈if (S.top==S.base) return OK;e=*--S.top;return OK;}/***********************************************************************Status Ini tQueue(L in kQueue &Q){// 构造一个空队列Q.fro nt=Q.rear=(QueuePtr)malloc(sizeof(QNode)); if(!Q.fro nt) exit(OVERFLOW); Q.fro nt-> next=NULL;return OK;}Status EnQueue(LinkQueue &Q,ElemType e){〃插入元素 e 为 Q 的新队列 struct QNode *p;p=(QueuePtr)malloc(sizeof(QNode));if(!p) exit(OVERFLOW);p->data=e;p->n ext=NULL;Q.rear- >n ext=p;Q.rear=p;return OK;}Status DeQueue(L in kQueue &Q,ElemType &e){struct QNode *p;if(Q.fro nt=Q.rear) return ERROR;p=Q.fr ont->n ext=p->n ext;if(Q.rear==p) Q.rear=Q.fr on t;free(p);return OK;}Stop_ma in. cpp:#i nclude"stop2.h"时间空格隔 mai n(){int i,t,f,m, n,s1_ num,Q_num;struct SqStack s1,s2;struct Lin kQueue Q;struct ElemType e,e1;s1_num=0;Q_num=0;t=0;m=0;In itStack(s1);l nitStack(s2);l ni tQueue(Q);printf("停车场的容量是:”);scan f("%d",&n);printf("输入车辆信息(E 为退出,A 为进入标志,D 为离开标志,车牌号 开):\n"); scan f("%s",e1.a);sca nf("%d%d", &e1. num, &e1.time); while(strcmp(e1.a,"E")!=0){if(strcmp(e1.a,"A")==0) {// 当有车辆进来的时候if(s1_ num<n) {Push(s1,e1);s1_ nu m++;printf("此车停在停车场第%d 辆\n",s1_num);}else {En Queue(Q,e1);Q_ nu m++;printf("此车停在便道距离门口第 %d 辆\n",Q_num);}}else if(strcmp(e1.a,"D")==0) {// 当有车辆离开的时候f=s1_num;for(i=0;i<f;i++){Pop(s1,e);s1_ nu m__;if(e1. num==e. nu m){ t=e1.time-e.time;m=M0NEY*t;printf (”此车停车时间 %d,所需费用%d 元\n",t,m);break;} else Push(s2,e);}if(t==0&&m==0){printf(" 此车为便道内车,故无需收费 \n");Q_num--;} while(s2.top!=s2.base){Pop(s2,e);Push(s1,e);s1_num++;}if(Q.fro nt!=Q.rear){DeQueue(Q,e);Push(s1,e);s1_ nu m++;}}else printf (” 错误 \n");printf("输入数据 \n");sca nf("%s",e1.a);sca nf("%d%d", &e1. num, &e1.time);}运行结果 tin-' 11-停车场第;!輛 辆 a 时进入标志,D 为离开柝志,车胆号时间空格隔开) exited after 63.54 seconds uith retuii'n ualuie Q i 青按任意键继綾…口 L:'数裾结构稈序\谆在场管理;停车场WH.exe。

C语言数据结构停车场管理系统 课题设计报告书

C语言数据结构停车场管理系统 课题设计报告书

一.需求分析(1).任务:设停车场是一个可停放n辆汽车的狭长通道,且只有一个大门可供汽车进出。

汽车在停车场内,按车辆到达时间的先后顺序,依次由北向南排列(大门在最南端,最先到达的第一辆车停放在车场的最北端)。

若车场内已停满n辆汽车,则后来的车只能在门外的便道上等候,一旦有车开走,则排在便道上的第一辆车即可开入。

当停车场内某辆车要离开时,在它之后进入的车辆必须先退出班车场为它让路,待该车开出大门后。

其他车辆再按原次序进入车场,每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用(在变道上停留的时间不收费)。

(2).基本要求:①以栈模拟停车场,以队列模拟车场外的便道。

②从终端读入汽车到达或离去的数据,每组包括三项:1.是“到达”还是“离去”;2.汽车牌照号码;3.“到达”或“离去”的时刻;(3).市场需求:这个软件可以合理的安排停车场车辆的存放,查询目前在停车辆,以及计费。

同时当停车场内部车辆方满之后,我们可以根据在外部等待的车辆的先来后到的顺序,当车场空闲之后,再安排等待的车辆进入。

同时在计费的反面,是按分钟计费的,较为公平。

最后收费,将小于0.1元部分四舍五入。

二.概要设计模块大致划分:界面:main函数;Memu函数(主要界面)计算函数1.进入函数GoIn();2离开函数GoOut().;查看函数3.查看车场LookChang();4.查看变道LookDao();遇到的疑难问题1.根据题目要求,停车场需要用栈,而变道要用的是列队。

由于变道的原则是先到先离开,这和列队的原理是一样的,所以变道的建立是方便的,只要实现变道(列队)和停车场(栈)之间的数据连接即可。

但是栈是后入先出的,而停车场呢的车辆的离开时没有规律的,这样删除数据是十分不方便的2.同时在车辆的离去方面有,根据题目的要求,我们要计算出车俩的停车费用。

由于时间是60进制,而车辆的停车的费用是同过车辆的的停车时长来求的,那么便是通过离去的时间减去进入的时间来得出中间的时间,最后求出来的。

数据结构停车场收费系统管理实践报告

数据结构停车场收费系统管理实践报告

数据结构停车场收费系统管理实践报告停车场收费系统,这个话题一提起来,大家都不陌生。

说实话,谁没在大街小巷的停车场为了一块停车费而头疼过呢?尤其是在城市里,停车位稀缺,收费又是天价,弄得有时候进个停车场就像进了赌场,不知道到底会“亏”多少。

今天就聊聊我最近搞的一次“停车场收费系统管理实践”,说实话,整个过程就像是看一部高能悬疑片,既有趣又有点小紧张。

停车场的管理,说白了,就是得搞清楚停车位的利用率,然后合理收费,确保不亏本。

这听起来简单,但要做好,光靠脑袋里的想法可不行。

得用点“硬核”的东西,比如数据结构。

说到这里,很多人可能开始懵了:数据结构?那是啥?别担心,数据结构就是一堆有序的、按照特定规则组织起来的数据,简单点说,就是停车场的“内部管理”嘛。

比如你停车时,停车场会分配一个车位给你,那些车位就得按照一定的规则排序,不然你想找个位置就得像大海捞针一样。

我们做的这个停车场收费系统,首先就要搞清楚如何让停车位、车主和收费三个元素高效地“打交道”。

你想,假如停车场没有规则,那就乱套了,车位没人用,车主也找不到地方停车,收费自然就乱七八糟了。

搞清楚了这些,系统的基础架构就稳了。

说到收费,最常见的就是按时间收费。

我们通过程序算出来每个车主停车的时长,再按照预设的费用标准进行结算。

这里就得用到“链表”这个数据结构了。

车主的停车信息就像一颗颗“珠子”串在一起,每个珠子里面有车主的停车时间、车牌号、停车收费等数据。

如果一个车主停车时间很长,那收费就得按时间增加,反之,停车时间短,自然收费也少。

这种管理方式非常高效,不容易出错,而且能够快速计算每个车主的停车费。

哎,说实话,我一开始听到链表这俩字儿时,还挺疑惑的,感觉好像很“高大上”,但一弄明白后,才发现原来就是个简单又实用的东西,跟停车场的条理化管理一样,处理起来简洁又明了。

再说到停车收费的“智能化”,以前我们去停车场,不是排队等着人工收费,就是站在收费亭前一脸懵逼,不知道到底该怎么付。

c语言数据结构停车场系统实验报告

c语言数据结构停车场系统实验报告

实验题目:实验六停车场管理一、需求分析1.程序的功能:设停车场内只有一个可停放n辆汽车的狭长通道,且只有一个大门可供汽车进出。

汽车在停车场内按车辆到达时间的先后顺序,依次由北向南排列〔大门在最南端,最先到达的第一辆车停放在车场的最北端〕,假设车场内已停满n辆汽车,那么后来的汽车只能在门外的便道上等候,一旦有车开走,那么排在便道上的第一辆车即可开入;当停车场内某辆车要离开时,在它之后开入的车辆必须先退出车场为它让路,待该辆车开出大门外,其它车辆再按原次序进入车场,每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。

〔1〕建立静态数组栈作为模拟停车场,动态链表栈作为模拟便道。

〔2〕车辆到达,停入停车场或者便道,记录车牌号,到达时间。

〔3〕车辆离开,记录离开时间,输出停车时间和收费。

将便道内车停入停车场,记录进入时间。

〔4〕列表显示停车场,便道内车辆情况。

〔5〕列表显示历史记录〔已经离开车的车牌号,到达离开时间,收费〕。

2.输入输出的要求:(1)输入:字符串车牌号,到达时间,离开时间(2)输出:停车时间和收费,停车场和便道的停车情况,历史记录。

3.测试数据:二.概要设计4.本程序所用的抽象数据类型的定义ADT Stack{数据对象:D={ai|ai为ElemSet,i为正整数}数据关系:R1={<ai-1,ai>|ai-1,ai都属于D,i为正整数}根本操作:InitStack(&S) //构建一个空栈SDestroyStack(&S) //S 被销毁StackLength(S) //返回S 的元素个数,即栈的长度。

StackEmpty(s) //假设栈S 为空栈,那么返回TRUE,否那么FALE。

GetTop(S, &e) //用e 返回S 的栈顶元素ClearStack(&S) //将S 清为空栈Push(&S, e) //入元素e 为新的栈顶元素。

停车场管理系统 C语言实习报告

停车场管理系统  C语言实习报告

C语言课程实习报告【要求】设有一个可以停放n辆汽车的狭长停车场,它只有一个大门可以供车辆进出。

车辆按到达停车场时间的早晚依次从停车场最里面向大门口停放(最先到达的第一辆车放在停车场的最里面)。

如果停车场已放满n辆车,则后来的车辆只能在停车场大门外的便道上等待,一旦停车场内有车开走,则排在便道上的第一辆车就进入停车场。

停车场内如有某辆车要开走,在它之后进来的车都必须先退出停车场为它让路,待其开出停车场后,这些车辆再依原来的次序进场。

每辆车在离开停车场时,都应依据它在停车场内停留的时间长短交费。

如果停留在便道上的车未进停车场就要离去,允许其离去,不收停车费,并且仍然保持在便道上等待的车辆的次序。

编制一程序模拟停车场管理。

【提示】汽车的模拟输入信息格式可以是:(到达/离去,汽车牌照号码,到达/离去的时刻)。

基本要求:要求程序输出每辆车到达后的停车位置(停车场或便道上),以及某辆车离开停车场时应交纳的费用和它在停车场内停留的时间。

根据题目要求,停车场可以用一个长度为n 的堆栈来模拟。

由于停车场内如有某辆车要开走,在它之后进来的车辆都必须先退出停车场为它让路,待其开出停车场后,这些车辆再依原来的次序进场,所以可以设两个堆栈。

一、需求分析根据题目要求,程序应该提供“到达/离去,汽车牌照号码,到达/离去”的输入、输出操作;在程序中需要浏览停车场的车位信息,应提供显示、查找、排序等操作;此外还应提供键盘式菜单实现功能选择。

二、总体设计:根据需求分析,可以将系统的设计分为以下五大模块:(1)车辆进入;(2)车辆退出;(3)车辆等待;(4)车辆查询;(5)退出。

一、详细设计:主函数中只包含菜单函数,菜单部分单独写成函数,只提供输入、功能处理和输出部分的函数调用,其中各功能模块用菜单方式选择。

[程序]#define N 30 /*等待车辆*/#define M 20 /*车位*/#define P 2 /*单位时间所收费用*/#include<stdio.h>#include<stdlib.h>#include<string.h>struct cars /*定义车辆信息*/{ char state;int num;int in_time; 停车场管理系统车辆进入 车辆退出 车辆等待 车辆信息显示车辆查询 退出系统int out_time;int time_spend;int money_to_pay;}car[M];struct carleft{ char state;int num;}wait[N];1、主函数模块[流程图][程序]main() /*主函数*/{pre_manage();menu(); /*调用主菜单函数*/return 0;}void menu() /*主菜单函数*/{int n,w;do{puts("\t\t************************MENU*******************\n\n");puts("\t\t\t\t 1.car_arrive"); /*有车到来*/puts("\t\t\t\t 2.car_depart"); /*有车离开*/puts("\t\t\t\t 3.car_browse"); /*浏览车位信息*/ puts("\t\t\t\t 4.exit"); /*退出*/ puts("\n\n\t\t *********************************************\n") printf("Choice your number(1-4):[ ]\b\b"); /*选择所需服务*/scanf("%d",&n);getchar();if(n<1||n>4){ w=1; getchar();}else w=0;} while(w==1);switch(n){case 1: car_arrive();break;case 2: car_depart();break;case 3: car_browse();break;case 4: exit(0);}}void pre_manage() /*循环结构*/{ int i;for(i=0;i<M;i++)car[i].state='E';for(i=0;i<N;i++)wait[i].state='E';}2、各功能模块设计:(1)、车辆进入模块[分析]车辆进入停车场后,判断车位和等待车位是否有剩余。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
} Status Push(SqStack &S,ElemType e){//插入元素 e 为新的栈顶元素
if(S.top-S.base>=S.stacksize){//栈满,追加存储空间 S.base=(ElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemType));
char a[3]; int num; int time; }ElemType; typedef struct SqStack{ ElemType *base; ElemType *top; int stacksize; }SqStack;//栈的表示 typedef struct QNode{ ElemType data; struct QNode *next; }QNode,*QueuePtr;//队列的表示 typedef struct LinkQueue{ QueuePtr front;//队头指针
QueuePtr rear;//队尾指针
}LinkQueue; Status InitStack(SqStack &S);//构造空栈 Status Push(SqStack &S,ElemType e);//进栈 Status Pop(SqStack &S,ElemType &e);//出栈 Status InitQueue(LinkQueue &Q);//构造一个空队列 Status EnQueue(LinkQueue &Q,ElemType e);//入队 Status DeQueue(LinkQueue &Q,ElemType &e);//出队
p=(QueuePtr)malloc(sizeof(QNode)); if(!p) exit(OVERFLOW); p->data=e;p->next=NULL; Q.rear->next=p; Q.rear=p; return OK; } Status DeQueue(LinkQueue &Q,ElemType &e){ struct QNode *p; if(Q.front=Q.rear) return ERROR; p=Q.front->next=p->next; if(Q.rear==p) Q.rear=Q.front; free(p); return OK; }
//构造一个空栈 Status Push(SqStack &S,ElemType e) //插入元素 e 为新的栈顶元素 Status Pop(SqStack &S,ElemType &e) //若栈不空,则删除 S 的栈顶元素,用 e 返回其值,并返回 OK;否则返回 ERROR Status InitQueue(LinkQueue &Q) //构造一个空队列 Q Status EnQueue(LinkQueue &Q,ElemType e) //插入元素 e 为 Q 的新队列 Status DeQueue(LinkQueue &Q,ElemType &e) //若队列不空,则删除 Q 的对头元素,用 e 返回其值,并返回 Ok; 否则返回 ERROR; <3>部分操作的算法 Status InitStack(SqStack &S){//构造一个空栈
Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode)); if(!Q.front) exit (OVERFLOW);//存储分配失败 Q.front->next=NULL; return OK; } Status EnQueue(LinkQueue &Q,ElemType e){//插入元素 e 为 Q 的 新队列 p=(QueuePtr)malloc(sizeof(QNode));//存储分配失败 if(!p) exit(OVERFLOW); p->data=e;p->next=NULL; Q.rear->next=p; Q.rear=p; return OK; } Status DeQueue(LinkQueue &Q,ElemType &e){ //若队列不空,则删除 Q 的对头元素,用 e 返回其值,并返回 Ok;否 则返回 ERROR; if(Q.front==Q.rear) return ERROR; p=Q.front->next; e=p->data; Q.front->next=p->next; if(Q.rear==p) Q.rear=Q.front;
if(!S.base) exit(OVERFLOW); S.top=S.base+S.stacksize; S.stacksize+=STACK_INIT_SIZE; } *S.top++=e; return OK; } Status Pop(SqStack &S,ElemType &e){//出栈 if (S.top==S.base) return OK; e=*--S.top; return OK; }
/***********************************************************************队列*/ Status InitQueue(LinkQueue &Q){//构造一个空队列
Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode)); if(!Q.front) exit(OVERFLOW); Q.front->next=NULL; return OK; } Status EnQueue(LinkQueue &Q,ElemType e){//插入元素 e 为 Q 的新队列 struct QNode *p;
数据结构
课程设计
题目 停车场管理器设计
专业:计算机科学与技术 班级:1401 姓名:彭旭
学号:143230135
实验主要内容
以栈模拟停车场,以队列模拟车场外的便道,按照从终端读
入的输入数据序列进行模拟管理。每一组输入数据包括三个数据
项:汽车“达到”或“离去”信息、汽车牌照号码以及达到或离
去的时刻。对每一组输入数据进行操作后的输出信息为:若是车
InitQueue(&Q); 操作结果:构造一个空队列 Q EnQueue(&Q,&e); 初始条件:对列 Q 已存在。 操作结果:插入元素 e 为 Q 的新队尾元素。 DeQueue(&Q,&e); 初始条件:对列 Q 已存在。 操作结果:删除 Q 的队头元素, 并用 e 返回。 }ADT Queue (2)本程序包含七个模块: <1>主程序模块,其中主函数为 Void main(){ 初始化;
free(p);
return OK;
}
源程序
Stop1.h: #include <stdio.h> #include <process.h> #include <malloc.h> #include <string.h> //------------------------函数结果状态代码 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define TNFEASIBLE -1 #define OVERFLOW -2 //Status 是函数的类型,其值是函数结果状态代码 typedef int Status; #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define MONEY 3 Stop2.h: #include"stop1.h" typedef struct ElemType{
构造空栈; 输入已知数据; 插入数据入栈; 分析 {入栈;出栈;入队;出队;} 输出数据; } <2>构造栈模块-----构造一个空栈; 栈插入模块-----插入新的数据元素; 栈删除模块-----删除指定的数据元素; 构造队列模块-----构造一个空队列; 队列插入模块-----插入新的数据元素; 队列删除模块-----删除指定的数据元素; (3)各模块之间的调用关系图解:
S.base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType));
if(!S.base) exit (OVERFLOW); S.top=S.base; S.stacksize=STACK_INIT_SIZE; return OK; }
Status Push(SqStack &S,ElemType e){//插入元素 e 为新的栈顶元 素
Stop.cpp: #include"stop2.h"
Status InitStack(SqStack &S){//构造空栈 S.base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType)); if(!S.base) exit(OVERFLOW); S.top=S.base; S.stacksize=STACK_INIT_SIZE; return OK;
主函数模块
分析
构造栈模块
栈插入模块
栈删除模块 构造队列模块 队列插入模块 队列删除模块
2.详细设计 <1>类型定义
#define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define MONEY 3
typedef int Status; typedef struct ElemType{
if(S.top-S.base>=S.stacksize){//栈满,追加存储空间 S.base=(ElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemT ype));
相关文档
最新文档