数据结构-停车场管理系统实验报告
停车场管理实验报告3篇
停车场管理实验报告第一篇：实验简介本次实验是关于停车场管理的，旨在探讨停车场的管理方法以及利用计算机技术对停车场进行智能管理的可行性。
实验过程中，我们首先对停车场的基本情况进行了调查和分析，并确定了停车场的布局和车位数量。
然后，我们设计了一个基于计算机视觉技术的车牌识别系统，能够自动识别汽车牌照，并将其和相应的车位绑定。
最后，我们开发了一个基于云端的管理系统，能够实时监控停车场的使用情况，统计收益和预测流量，优化停车场管理。
通过本次实验，我们希望能够提高停车场的利用率，降低管理成本，提高用户体验。
第二篇：实验步骤1. 调查和分析首先，我们对停车场的周边环境、车流量、停车需求等进行了调查和分析，并根据调查结果确定了停车场的布局和车位数量。
2. 设计车牌识别系统我们采取了基于计算机视觉技术的车牌识别系统，能够自动识别汽车牌照，并将其和相应的车位绑定。
该系统主要分为以下三个部分：（1）摄像头：采用高清摄像头，能够自动对焦和自动曝光，提高识别准确率。
（2）软件系统：采用OpenCV图像处理库进行开发，能够自动识别车牌，并提取车牌号码信息。
（3）数据存储：采用MySQL数据库进行存储，能够存储车牌号码和相应的车位信息，方便管理。
3. 开发管理系统我们开发了一个基于云端的管理系统，能够实时监控停车场的使用情况，统计收益和预测流量，优化停车场管理。
该系统主要包括以下功能：（1）实时监控：通过车牌识别系统和摄像头，能够实时监控停车场内的车辆，并提供车位信息和空余位置。
（2）预约停车：用户可以通过手机或网站进行预约停车，并预定相应的车位。
（3）收费管理：管理人员可以通过系统对停车场的收费进行监控和管理，能够统计收益和优化停车场营运。
4. 测试和优化最后，我们进行了系统的测试和优化，并对系统的性能进行了评估和改进，确保停车场管理系统的稳定和可靠性。
第三篇：实验结果与展望经过长时间的实验和努力，我们开发出了一套基于计算机视觉技术的停车场管理系统，能够实现车辆自动识别和智能管理。
《数据结构》停车场系统设计报告--停车场管理系统_
《数据结构》停车场系统设计报告--停车场管理系统_一、系统总体原则1.1、系统的安全性：停车场管理系统要求引入多重安全措施，确保其系统数据的安全，以防止非法黑客进行攻击；系统本身要具备安全保护机制，确保核心系统重要功能不能被破坏。
1.2、系统功能：停车场管理系统要具备通行证管理，车辆管理，收费管理，维修管理，系统权限控制和固定车位管理等多种功能。
1.3、系统数据管理：停车场管理系统要实现对用户信息，车辆信息，收费信息，维修信息和工作日志等数据的便捷管理；支持数据注入，报表输出，日志查询，备份恢复等。
二、系统数据结构2.1、用户信息结构：用户类型、用户名、密码、真实姓名、联系电话、优惠折扣比、优惠申请次数等2.2、车辆信息结构：车牌号、车牌颜色、停放位置、停放时间、收费金额等2.3、收费信息结构：收费时间、车牌号、应缴金额、实缴金额、优惠金额、收费员等2.4、维修信息结构：维修时间、车牌号、维修内容、维修费用、维修人等2.5、工作日志结构：日志类型、生成时间、触发时间、操作内容、操作人等三、系统模块设计通行证管理模块：能够管理停车场的客户信息，支持优惠折扣的设置，支持多种客户角色的分配及权限管理。
车辆管理模块：能够管理停车场的车辆信息，支持分配停车位、跟踪车辆停放时间以及出入位置，以实现计算停车费用。
收费管理模块：能够实现车辆停放费用的计费与收取，支持优惠计算功能，支持收费记录的查询与管理。
维修管理模块：能够管理停车场的车辆维修信息，能够针对每辆车的维修记录进行查询、录入和管理。
系统权限控制模块：支持可根据多种角色分配权限，以实现系统模块及功能的控制，保证信息安全性。
固定车位管理模块：能够支持固定车位信息的管理，可支持用户管理固定车位，以便系统自动识别用户并提供优惠处理。
四、系统实现方案4.1 前端 : 对停车场系统进行交互式操作，支持web，客户端，短信等界面，实现用户的操作及查询；前端应用可跨平台进行。
停车系统实验报告
一、实验背景随着城市化进程的加快，汽车数量不断增加，停车难问题日益突出。
为了提高停车效率，减少交通拥堵，实现停车场管理的智能化，我们设计并实现了一个基于数据结构的停车场管理系统。
本系统采用栈和队列数据结构模拟停车场的运行过程，实现了车辆进出、停车位置分配、费用计算等功能。
二、实验目的1. 理解并掌握栈和队列数据结构在停车场管理中的应用。
2. 设计并实现一个停车场管理系统，实现车辆进出、停车位置分配、费用计算等功能。
3. 体会数据结构在实际问题中的应用价值。
三、实验内容1. 系统设计（1）数据结构设计停车场：采用顺序栈实现，栈顶表示停车场最北端，栈底表示停车场最南端。
便道：采用链队列实现，队首表示便道最北端，队尾表示便道最南端。
汽车信息：定义一个结构体，包含车牌号、到达时间、离开时间、停车费用等属性。
（2）功能模块设计进出停车场：根据车辆到达或离开的时间，判断车辆是进入停车场还是离开停车场。
停车位置分配：根据停车场和便道的实际情况，为车辆分配停车位置。
费用计算：根据车辆在停车场停留的时间，计算停车费用。
输出结果：输出每辆车到达后的停车位置、离开时的费用和停留时间。
2. 系统实现（1）数据结构实现顺序栈：使用数组实现，提供入栈、出栈、判空等操作。
链队列：使用链表实现，提供入队、出队、判空等操作。
（2）功能模块实现进出停车场：根据车辆到达或离开的时间，判断车辆是进入停车场还是离开停车场。
停车位置分配：根据停车场和便道的实际情况，为车辆分配停车位置。
费用计算：根据车辆在停车场停留的时间，计算停车费用。
输出结果：输出每辆车到达后的停车位置、离开时的费用和停留时间。
3. 系统测试（1）功能测试测试车辆进出停车场功能。
测试停车位置分配功能。
测试费用计算功能。
（2）性能测试测试系统在高并发情况下的性能。
四、实验结果与分析1. 功能测试结果经过测试，系统各项功能均能正常运行，满足设计要求。
2. 性能测试结果在高并发情况下，系统运行稳定，性能良好。
数据结构停车场问题实验报告
数据结构课程设计——停车场管理问题姓名：学号：一、问题描述设有一个可以停放n辆汽车的狭长停车场，它只有一个大门可以供车辆进出。
车辆按到达停车场时间的早晚依次从停车场最里面向大门口处停放(最先到达的第一辆车放在停车场的最里面)。
如果停车场已放满n辆车，则后来的车辆只能在停车场大门外的便道上等待，一旦停车场内有车开走，则排在便道上的第一辆车就进入停车场。
停车场内如有某辆车要开走，在它之后进入停车场的车都必须先退出停车场为它让路，待其开出停车场后，这些车辆再依原来的次序进场。
每辆车在离开停车场时，都应根据它在停车场内停留的时间长短交费。
如果停留在便道上的车未进停车场就要离去，允许其离去，不收停车费，并且仍然保持在便道上等待的车辆的次序。
编制一程序模拟该停车场的管理。
二、实现要求要求程序输出每辆车到达后的停车位置(停车场或便道上)，以及某辆车离开停车场时应交纳的费用和它在停车场内停留的时间。
三、实现提示汽车的模拟输入信息格式可以是：(到达／离去，汽车牌照号码，到达／离去的时刻)。
例如，(‘A’，，1，5)表示1号牌照车在5这个时刻到达，而(‘D’，，5，20)表示5号牌照车在20这个时刻离去。
整个程序可以在输入信息为(‘E’，0，0)时结束。
本题可用栈和队列来实现。
四、需求分析停车场采用栈式结构，停车场外的便道采用队列结构（即便道就是等候队列）。
停车场的管理流程如下①当车辆要进入停车场时，检查停车场是否已满，如果未满则车辆进栈（车辆进入停车场）；如果停车场已满，则车辆进入等候队列（车辆进入便道等候）。
②当车辆要求出栈时，该车到栈顶的那些车辆先弹出栈（在它之后进入的车辆必须先退出车场为它让路），再让该车出栈，其他车辆再按原次序进栈（进入车场）。
当车辆出栈完毕后，检查等候队列（便道）中是否有车，有车则从队列头取出一辆车压入栈中。
五、流程图六、详细设计1.本程序主要包含四个模块1) 主程序模块int main(){Initialization();CarNode car;SqStack Park,TempPark;LinkQueue Q;InitStack(Park);InitStack(TempPark);InitQueue(Q);while((scanf("%c%d%d",&car.event,&car.num,&car.time))&&(car.event!='e'&&car .event!='E')){getchar();//除去输入结束时的回车switch(car.event){case 'A':case 'a':Arrive(Park,Q,car);break;case 'D':case 'd':Leave(Park,TempPark,Q,car);break;default: printf("您的第一个数据输入有误!\n");break;}}printf("程序结束，谢谢使用!\n");return 0;2）分别构造空栈和空队列栈：Status InitStack(SqStack &S){ //构造一个空栈S.Stacksize=0;S.base=(CarNode*)malloc((MAX)*sizeof(CarNode));if(!S.base){exit(OVERFLOW);printf("存储空间分配失败");}S.top=S.base;return OK;}队列：Status InitQueue(LinkQueue &Q){ //构造一个空队列（带头结点）Q.front=Q.rear=(QueueNode*)malloc(sizeof(QueueNode));if(!Q.front){exit(OVERFLOW);printf("存储空间分配失败");}Q.front->next=NULL;Q.queuesize=0;return OK;3）车辆到达处理Status Arrive(SqStack &S,LinkQueue &Q,CarNode &e){ //车辆到达处理if((S.top-1)->time<=e.time){ //时间处理if(!Check_Stack(S,e)&&!Check_Queue(Q,e)){ //是否已存在if(S.top-S.base<MAX){Push(S,e);printf("成功进入停车场,在%d号车库!\n",S.top-S.base);return OK;}else{EnQueue(Q,e);printf("停车场已满，车辆进入便道,在%d号车位!\n",Q.queuesize);}}elseprintf("该牌照的车已存在，输入有误，请重新输入\n");return OK;}else{printf("时间输入有误，请重新输入!\n");return FALSE;}}4）车辆离开处理Status Leave(SqStack &S,SqStack &TempS,LinkQueue &Q,CarNode &e){//车辆离开处理CarNode a;int leatime,leanum;intentertime; //进入停车场时间int cost;if(!(Check_Stack(S,e) || Check_Queue(Q,e))){printf("数据输入错误，本停车场内无所查询车辆，请重新输入！\n");return true;}else{if(Check_Stack(S,e)) //若需要离开的车辆在停车场{if(e.num==(S.top-1)->num)//车辆处在栈顶{Pop(S, a);leatime=e.time;leanum=e.num;entertime=a.time;printf("车辆进入车库时间:%d\t现在（离开）时间:%d\t停留时间:%d\t\n",entertime,leatime,leatime-entertime);}else//车辆处在栈中间{do{Pop(S,a);//从栈中依次退出Push(TempS,a);//依次进入临时栈}while((S.top-1)->num!=e.num);//直到top指针下一个位置的num=车牌号Pop(S,a); //该车离开leatime=e.time;leanum=e.num;entertime=a.time;printf("车进入停车场时间:%d\t现在（离开）时间:%d\t停留时间:%d\t\n",entertime,leatime,leatime-entertime);do{ //其余车辆按原来次序返回停车场Pop(TempS,a);Push(S,a);}while(TempS.top!=TempS.base);//条件与上面不同，此时是全部回去}cost=(leatime-entertime)*price;if(cost>=0)printf("您的车牌号为 %d 的车应交纳的费用是:%d\n",leanum,cost);if(Q.front!=Q.rear){//队列不空的话从便道进停车场DeQueue(Q,a);if(a.time<leatime) //便道车辆进车库时间应该比车库车辆离开时间晚entertime=leatime;a.time=leatime;Push(S,a);//该车进入停车场printf("车牌号为%d的车辆从便道上进入%d号车库!从现在开始计时，现在时间为：%d\n",a.num,S.top-S.base,a.time);}}else if(Check_Queue(Q,e)){ //从便道直接离开do{DeQueue(Q,a);EnQueue(Q,a);}while(Q.front->next->data.num!=e.num);DeQueue(Q,e);//前面的车进入队尾printf("您的车牌号为 %d 的车辆未进入车库从便道直接离开，费用为0!\n",e.num);}}return true;2．主要设计程序如下#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define MAX 2 //停车场容量#define price 2 //单价#define OK 1#define FALSE 0#define TRUE 1#define ERROR -1#define OVERFLOW -2typedef int Status;//===================================================================== typedef struct CarNode{char event;int num;int time;}CarNode; //车辆信息结点typedef struct SqStack{CarNode *base;CarNode *top;int Stacksize;}SqStack; //栈（停车场）typedef struct QNode{CarNode data;struct QNode *next;}QueueNode; //便道结点typedef struct LinkQueue{QueueNode *front;QueueNode *rear;int queuesize;}LinkQueue; //队列（便道）//===================================================================== Status InitStack(SqStack &S){ //构造一个空栈S.Stacksize=0;S.base=(CarNode*)malloc((MAX)*sizeof(CarNode));if(!S.base){exit(OVERFLOW);printf("存储空间分配失败");}S.top=S.base;return OK;}//===================================================================== Status InitQueue(LinkQueue &Q){ //构造一个空队列（带头结点） Q.front=Q.rear=(QueueNode*)malloc(sizeof(QueueNode));if(!Q.front){exit(OVERFLOW);printf("存储空间分配失败");}Q.front->next=NULL;Q.queuesize=0;return OK;}//=====================================================================Status GetTop(SqStack S,CarNode &e){ //返回栈顶元素if(S.top==S.base)return ERROR;e=*(S.top-1);return TRUE;}//===================================================================== Status Pop(SqStack &S,CarNode &e){ //删除栈顶元素if(S.top==S.base)return ERROR;e=*--S.top;return OK;}//===================================================================== Status Push(SqStack &S,CarNode e){//插入元素为新的栈顶元素(在栈不满的前提下) if(S.top-S.base>=MAX)return FALSE;*S.top++=e;return OK;}//===================================================================== Status DeQueue(LinkQueue &Q,CarNode &e){ //删除队头元素(带头结点) if(Q.rear==Q.front)return ERROR;QueueNode *p=Q.front->next;e=p->data;Q.front->next=p->next;if(p==Q.rear)Q.rear=Q.front;free(p);Q.queuesize--;return OK;}//===================================================================== Status EnQueue(LinkQueue &Q,CarNode e){ //插入新的队尾元素QueueNode *p=(QueueNode*)malloc(sizeof(QueueNode));if(!p)exit(OVERFLOW);p->data=e;p->next=NULL;Q.rear->next=p;Q.rear=p;Q.queuesize++;return OK;}//===================================================================== Status Check_Stack(SqStack &S,CarNode e){//车辆到达时车库内是否有同名车 CarNode *Temp=S.base;while((Temp!=(S.top))&&(Temp->num!=e.num))Temp++;if((Temp==S.top))return FALSE;elsereturn TRUE;}//===================================================================== Status Check_Queue(LinkQueue &Q,CarNode e){//车辆到达时便道上是否有同名车 QueueNode *Temp=Q.front;while((Temp!=Q.rear) && (Temp->data.num!=e.num))Temp=Temp->next;if((Temp==Q.rear) && (Temp->data.num!=e.num))return FALSE;elsereturn TRUE;}//=====================================================================Status Arrive(SqStack &S,LinkQueue &Q,CarNode &e){ //车辆到达处理if((S.top-1)->time<=e.time){ //时间处理if(!Check_Stack(S,e)&&!Check_Queue(Q,e)){ //是否已存在if(S.top-S.base<MAX){Push(S,e);printf("成功进入停车场,在%d号车库!\n",S.top-S.base);return OK;}else{EnQueue(Q,e);printf("停车场已满，车辆进入便道,在%d号车位!\n",Q.queuesize);}}elseprintf("该牌照的车已存在，输入有误，请重新输入\n");return OK;}else{printf("时间输入有误，请重新输入!\n");return FALSE;}}//=====================================================================Status Leave(SqStack &S,SqStack &TempS,LinkQueue &Q,CarNode &e){//车辆离开处理CarNode a;int leatime,leanum;intentertime; //进入停车场时间int cost;if(!(Check_Stack(S,e) || Check_Queue(Q,e))){printf("数据输入错误，本停车场内无所查询车辆，请重新输入！\n");return true;}else{if(Check_Stack(S,e)) //若需要离开的车辆在停车场{if(e.num==(S.top-1)->num)//车辆处在栈顶{Pop(S, a);leatime=e.time;leanum=e.num;entertime=a.time;printf("车辆进入车库时间:%d\t现在（离开）时间:%d\t停留时间:%d\t\n",entertime,leatime,leatime-entertime);}else//车辆处在栈中间{do{Pop(S,a);//从栈中依次退出Push(TempS,a);//依次进入临时栈}while((S.top-1)->num!=e.num);//直到top指针下一个位置的num=车牌号Pop(S,a); //该车离开leatime=e.time;leanum=e.num;entertime=a.time;printf("车进入停车场时间:%d\t现在（离开）时间:%d\t停留时间:%d\t\n",entertime,leatime,leatime-entertime);do{ //其余车辆按原来次序返回停车场Pop(TempS,a);Push(S,a);}while(TempS.top!=TempS.base);//条件与上面不同，此时是全部回去}cost=(leatime-entertime)*price;if(cost>=0)printf("您的车牌号为 %d 的车应交纳的费用是:%d\n",leanum,cost);if(Q.front!=Q.rear){//队列不空的话从便道进停车场DeQueue(Q,a);if(a.time<leatime) //便道车辆进车库时间应该比车库车辆离开时间晚entertime=leatime;a.time=leatime;Push(S,a);//该车进入停车场printf("车牌号为%d的车辆从便道上进入%d号车库!从现在开始计时，现在时间为：%d\n",a.num,S.top-S.base,a.time);}}else if(Check_Queue(Q,e)){ //从便道直接离开do{DeQueue(Q,a);EnQueue(Q,a);}while(Q.front->next->data.num!=e.num);DeQueue(Q,e);//前面的车进入队尾printf("您的车牌号为 %d 的车辆未进入车库从便道直接离开，费用为0!\n",e.num);}}return true;}//=====================================================================voidInitialization(){ //初始化程序printf("姓名：杨智伟学号：2012040651\n");printf("==========================================================\n");printf("* 停车场管理模拟程序 *\n");printf("==========================================================\n");printf("请依次输入车辆到达(A/a)/离去(D/d)/结束(E/e)信息、车牌号以及当前时间：\n\n");}//=====================================================================int main(){Initialization();CarNode car;SqStack Park,TempPark;LinkQueue Q;InitStack(Park);InitStack(TempPark);InitQueue(Q);while((scanf("%c%d%d",&car.event,&car.num,&car.time))&&(car.event!='e'&&car .event!='E')){getchar();//除去输入结束时的回车switch(car.event){case 'A':case 'a':Arrive(Park,Q,car);break;case 'D':case 'd':Leave(Park,TempPark,Q,car);break;default: printf("您的第一个数据输入有误!\n");break;}}printf("程序结束，谢谢使用!\n");return 0;}七、程序运行截图1．交互界面2．车辆进入3．车辆离去4．停车场已满进入便道5．便道车辆进入车库6．程序结束界面八、实验总结1．学会了栈和队列的综合使用，更加灵活运用栈和队列。
数据结构--停车场管理-完整版-实习报告
实习报告题目：停车场管理一．需求分析1．用栈来表示停车场，用队列来表示停车道。
2．用户需输入车辆的必要信息，如车辆的到达或离开，汽车牌号以及到达或离去的时刻。
停车场的容量及单位时间的停车费由编程序者自行设置，结构需输出车辆停车所需缴纳的费用。
3．本程序要求对车辆的动态能够输出具体的信息内容，包括停车或离开的时间，位置，及所需缴纳的停车费。
4．测试数据为：N=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.设定栈的抽象数据类型定义：ADT Stack{数据对象：D={ai|ai属于Elem,i=1,2……,n, n>=0}数据关系：R1={<ai-1, ai>| ai-1,ai属于D，i=2,……，n}基本操作：initStack(&S)操作结果：构造一个空栈S.pop(&S,&e)初始条件：栈S已存在。
操作结果：删除S的栈顶元素，并以e返回其值。
push(&S,&e )初始条件：栈S已存在。
操作结果：在栈S的栈顶插入新的栈顶元素e。
lengthstack(S)初始条件：栈S已存在。
操作结果：返回S中的元素个数，即栈的长度。
}ADT Stack;2.设定队列的抽象数据类型定义：ADT Queue{数据对象：D={ai| ai属于Elem, i=1,2,……，n, n>=0}数据关系：R1={<ai-1 ,ai>| ai-1,ai 属于D，i=2,……,n}基本操作：initqueue(&Q)操作结果：构造一个空队列Q.enqueue(&Q, e)初始条件：队列Q已存在。
数据结构停车场管理实验报告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}基本操作:InitStack(&S)操作结果：构造一个空栈S。
Push(&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为队尾基本操作:InitQueue(&Q);操作结果：构造一个空队列QEnQueue(&Q,&e);初始条件：对列Q已存在。
操作结果：插入元素e为Q的新队尾元素。
DeQueue(&Q,&e);初始条件：对列Q已存在。
操作结果：删除Q的队头元素, 并用e返回。
}ADT Queue（2）本程序包含七个模块：<1>主程序模块，其中主函数为Void main(){初始化；构造空栈；输入已知数据；插入数据入栈；分析{入栈；出栈；入队；出队；}输出数据；}<2>构造栈模块-----构造一个空栈；栈插入模块-----插入新的数据元素；栈删除模块-----删除指定的数据元素；构造队列模块-----构造一个空队列；队列插入模块-----插入新的数据元素；队列删除模块-----删除指定的数据元素；（3）各模块之间的调用关系图解：2．详细设计<1>类型定义#define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define MONEY 3typedef int Status;typedef struct ElemType{c har a[3];i nt num;i nt time;}ElemType;typedef struct SqStack {ElemType *base;//在栈构造之前和销毁之后,base的值为NULLElemType *top;//栈顶指针int stacksize;//当前已经分配的存储空间,以元素为单位}SqStack;//栈的表示typedef struct QNode{E lemType data;struct QNode *next;}QNode,*QueuePtr;//队列的表示typedef struct LinkQueue{QueuePtr front;//队头指针QueuePtr rear;//队尾指针}LinkQueue;<2>栈和队列的基本操作Status InitStack(SqStack &S)//构造一个空栈Status Push(SqStack &S,ElemType e)//插入元素e为新的栈顶元素Status Pop(SqStack &S,ElemType &e)//若栈不空，则删除S的栈顶元素，用e 返回其值，并返回OK；否则返回ERRORStatus InitQueue(LinkQueue &Q)//构造一个空队列QStatus EnQueue(LinkQueue &Q,ElemType e)//插入元素e为Q的新队列Status DeQueue(LinkQueue &Q,ElemType &e)//若队列不空,则删除Q的对头元素,用e返回其值,并返回Ok;否则返回ERROR;<3>部分操作的算法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;}Status Push(SqStack &S,ElemType e){//插入元素e为新的栈顶元素if(S.top-S.base>=S.stacksize){//栈满，追加存储空间S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemT ype));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 InitQueue(LinkQueue &Q){//构造一个空队列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 的新队列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;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 3Stop2.h:#include"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 *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);//出队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;}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 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;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;}Stop_main.cpp:#include"stop2.h"main(){int i,t,f,m,n,s1_num,Q_num;struct SqStack s1,s2;struct LinkQueue Q;struct ElemType e,e1;s1_num=0;Q_num=0;t=0;m=0;InitStack(s1);InitStack(s2);InitQueue(Q);printf("停车场的容量是:");scanf("%d",&n);printf("输入车辆信息（E为退出，A为进入标志，D为离开标志，车牌号时间空格隔开）：\n");scanf("%s",e1.a);scanf("%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_num++;printf("此车停在停车场第%d辆\n",s1_num);}else {EnQueue(Q,e1);Q_num++;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_num--;if(e1.num==e.num){t=e1.time-e.time;m=MONEY*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.front!=Q.rear){DeQueue(Q,e);Push(s1,e);s1_num++;}}else printf("错误\n");printf("输入数据\n");scanf("%s",e1.a);scanf("%d%d",&e1.num,&e1.time);}运行结果。
数据结构-停车场管理系统实验报告
数据结构-停车场管理系统实验报告数据结构停车场管理系统实验报告一、实验目的本次实验旨在通过设计和实现一个停车场管理系统，深入理解和应用数据结构的知识，包括栈、队列、链表等，提高编程能力和解决实际问题的能力。
二、实验环境本次实验使用的编程语言为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）测试停车场管理系统的功能：模拟多辆汽车进出停车场，检查系统是否能够正确地分配和释放停车位，并且能够正确地记录空余停车位数。
三、实验结果与分析本次实验使用栈和队列创建了一个简单的停车场管理系统，并测试了其基本功能。
在测试过程中，我们模拟了多辆汽车进出停车场，并检查了系统能否正确地分配和释放停车位。
实验结果表明，该系统可以正常工作，并且能够正确地记录空余停车位数。
四、实验总结通过本次实验，我们学习了如何使用栈和队列来创建一个简单的停车场管理系统。
同时，我们也深刻认识到数据结构在实际应用中的重要性。
在今后的学习中，我们将继续深入学习数据结构，并探索其更广泛的应用。
数据结构 停车场停车管理系统
数据结构课外实践报告项目名称：停车场停车管理系统所在班级：10级信管1班小组成员：杨剑楠孙迎张可可吴亮指导教师：王希杰起止时间：12月4日——12月22日项目基本信息课外实践评定成绩记录一、问题描述及分析1、问题描述：停车场停车管理系统：设一个可以停放n辆汽车停车场，只有一个大门可供汽车进出。
汽车在停车场内按车辆到达时间的先后顺序停放，若车场内已停满n辆车，那么后来的车只能在门外的便道上等候；一旦有车开走，则排在便道上的第一辆车即可开入。
当停车场内某辆车要离开时，在它之后进入的车辆必须先依次退出车场为它让路，待该辆车开出大门外，其它车辆再按原次序进入车场。
每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。
2、需求分析：（1）题目中要根据车辆停留时间收费，故在定义结构体时还需要一个时间的结构体用来保存车辆到达和离开的时间。
（2）由于停车场的进出符合栈的“后进先出，先进后出”的操作特点，因此，需要设一个栈来模拟停车场。
（3）根据便道停车的特点，先排队的车辆先离开便道进入停车场，符合队列的“先进先出，后进后出”的操作特点，因此，需要用一个队列来模拟便道。
（4）而中间车辆提出离开停车场，后到达的车辆都须先离开停车场为它让路，然后这些车辆再依原来次序进入停车场，而这个同样符合“后进先出，先进后出”的特点，因此还需一个栈来作为临时保存车辆的地方。
二、功能模块及数据结构描述1、功能模块：★主要功能：（1）车辆到达（2）车辆离开（3）信息查询★功能模块图：图1.功能模块图2、数据结构描述：（1）车辆信息的表示车辆可以看成是一个节点，设计成一个结构题，车辆信息包括：车牌号，车辆到达时间，车辆离开时间，定义如下：typedef struct node{char num[10]; //车牌号Time reach; //保存车辆到达的时间Time leave; //保存车辆离开的时间}CarNode;（2）时间、栈和队列的定义时间有小时、分钟和秒表示，即设计三个变量分别表示如下：typedef struct time{int hour;int min;int sec;}Time;停车场内用栈表示：typedef struct NODE{CarNode *stack[Max+1]; //栈用顺序表示int top;}SqStackCar;便道上的车辆表示：typedef struct car{CarNode *data; //便道上的车用链表表示struct car *next;}QueueNode;typedef struct Node{QueueNode *head; //设置头指针、尾指针QueueNode *rear;}LinkQueueCar;三、主要算法流程描述及部分核心算法（1）主函数的算法流程描述：图2.主函数流程图（2）核心算法流程描述：☆车辆到达：Arrival函数主要通过if（Enter->top<Max）来判断到达车辆是进车场还是进便道，如果进车场，就把top加1，同时记录进车场的位置和时间，然后结点进栈；如果进便道，进行队列操作。
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;//车离开停车场的时间};//车的类------------------------------------------------------------------------------------------------[测试方法、测试数据与测试结果]测试方法：需要输入停车场的停车位的数量和便道中可以等待的车位的数量，以及每小时停留在停车场中的花费。
智能停车系统实验报告(3篇)
第1篇一、实验目的随着城市化进程的加快，城市交通压力日益增大，停车难问题成为城市管理的一大难题。
为了解决这一问题，本研究旨在设计并实现一套智能停车系统，通过利用现代信息技术，提高停车场的运营效率，降低用户停车成本，缓解城市交通压力。
二、实验内容本次实验主要内容包括以下几个方面：1. 系统需求分析：分析停车场管理中存在的问题，确定系统功能需求。
2. 系统设计：根据需求分析，设计智能停车系统的整体架构、模块划分、功能实现等。
3. 系统实现：利用编程语言和开发工具，实现智能停车系统的各项功能。
4. 系统测试：对系统进行功能测试、性能测试、稳定性测试等，确保系统正常运行。
三、实验步骤1. 系统需求分析- 分析停车场管理中存在的问题，如车位利用率低、停车效率低、停车费用高、车位信息不透明等。
- 确定系统功能需求，包括车位管理、停车缴费、车位引导、用户管理、系统维护等。
2. 系统设计- 整体架构：采用分层架构，包括数据层、业务逻辑层、表现层等。
- 模块划分：将系统划分为多个模块，如用户模块、车位模块、缴费模块、引导模块等。
- 功能实现：利用编程语言和开发工具，实现各模块的功能。
3. 系统实现- 用户模块：实现用户注册、登录、修改密码等功能。
- 车位模块：实现车位分配、查询、预约等功能。
- 缴费模块：实现在线缴费、历史缴费记录查询等功能。
- 引导模块：实现车位引导、路径规划等功能。
- 系统维护：实现系统日志管理、数据备份等功能。
4. 系统测试- 功能测试：测试系统各项功能是否按照设计要求实现。
- 性能测试：测试系统在高峰时段的运行效率，确保系统稳定运行。
- 稳定性测试：测试系统在极端条件下的稳定性，确保系统安全可靠。
四、实验结果与分析1. 功能实现通过本次实验，成功实现了智能停车系统的各项功能，包括用户管理、车位管理、停车缴费、车位引导等。
用户可以通过手机APP或网页端实现车位查询、预约、缴费等功能，提高了停车效率。
数据结构课程设计停车场管理报告
数据结构课程设计《停车场管理》班级：姓名：学号：设计日期：2012年7月2日——2012年7月11日1）需求分析本次的数据结构课程设计所选的题目是停车场管理系统。
根据题目要求，已知停车场是一个可停放n辆汽车的狭长通道，只有一个大门可供汽车出入，由此可将停车场的类型定义为栈，其容量为n。
当停车场已经停满n辆车后，后来的车辆只能在便道上等待。
当停车场内有车开走，便道上的第一辆汽车便可以进入停车场中。
根据其先入先出的特点，可以将便道的类型定义为队列，容量不限。
由题目可知，需停车辆的信息包括：车牌号码、汽车“到达”“离去”的信息、“到达”“离去”的时刻等。
按照从终端读入的数据序列进行模拟管理。
每辆车需要三个数据，其中车辆数据为：A表示到达，D表示离去，E表示程序结束。
车辆牌照号码为整型数据，车辆到达或离开的时刻同样为整型数据。
输入车辆到达应该输出的信息为：汽车在停车场内或便道上的停车位置；输入车辆离开应该输出的信息为汽车在停车场内停留的时间和应交纳的费用（在便道上停留的时间不收费）。
停车场管理系统主要实现以下几个功能：(1)根据车辆到达停车场到车辆离开停车场时所停留的时间进行计时收费。
(2)该程序设计能够通过车牌号能查到该车辆在停车场或便道中的位置。
(3)当有车辆从停车场离开时，等待的车辆按顺序进入停车场停放。
实现停车场的调度功能。
该程序设计可以完整的模拟停车场的管理过程。
2）概要设计停车场管理系统是充分利用数据结构中栈和队列的思想实现的，栈是一种只能在叫做栈的一段进行进栈或者出栈操作的线性数据结构。
栈的主要特点是”后进先出”，即后进栈的元素先处理。
停车场的容量即为栈的存储空间，停车场的车辆的停靠是无秩序的，因此采用链式存储的方式更适合，也方便车辆的调度。
队列是限定仅能在表的一端进行插入，在表的另一端进行删除的线性表。
队列中可以插入的一端称为队尾，可以删除的一端称为队首。
把一个元素插入队列中的操作为进队，队列中删除一个元素的操作为出队。
数据结构停车场实习报告
一、实习背景随着我国经济的快速发展，城市车辆数量逐年攀升，停车难问题日益突出。
为了解决这一问题，我们需要设计一个高效、便捷的停车场管理系统。
本次实习以数据结构为基础，设计并实现了一个停车场管理系统。
二、实习目的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. 数据结构应用：成功将栈和队列应用于停车场管理系统，提高了系统性能。
数据结构 停车场管理报告
实验二：停车场管理（栈和队列应用）班级学号姓名一、实验目的1 掌握队列和栈顺序存储结构和链式存储结构，以便在实际背景下灵活运用。
2 掌握栈和队列的特点，即先进后出与先进先出的原则。
3 掌握栈和队列的基本运算。
二、实验内容1 问题描述设有一个可以停放n辆汽车的狭长停车场，它只有一个大门可以供车辆进出。
车辆按到达停车场时间的早晚，依次从停车场最里面向大门口处停放。
如果停车场已放满n辆车，则后来的车辆只能在停车场大门外的便道上等待，一旦停车场内有车开走，则排在便道上的第一辆车就进入停车场。
停车场内如有某辆车要开走，在它之后进入停车场的车都必须退出停车场为它让路，待其开出停车场后，这些车辆再依原来的次序进场。
每辆车在离开停车场时，都应根据它在停车场内停留的时间长短来交费。
如果停留在便道上的车未进入停车场就要离去，允许其离开，不收停车费，并且仍然保持在便道上等待的车辆次序。
编制一个程序模拟该停车场的管理。
2 实现要求要求程序输出每辆车到达后的停车位置（停车场或便道），以及某辆车离开停车场时应该交纳的费用和它在停车场内停留的时间。
3 实现提示汽车的模拟输入信息格式可以为：（到达/离开，汽车牌照号码，到达/离开的时间）。
用栈和队列来模拟停车场和便道。
三、实验结果：头文件#define MAXSIZE 3#define price 0.4typedef struct time {int hour;int min;}Time;typedef struct car {char num[10];Time reach;Time leave;}CarNode;typedef struct SNode {CarNode *data1[MAXSIZE+1];int top;}SeqStackCar;typedef struct QNode {CarNode *data2;struct QNode *next;}QueueNode;typedef struct LQNode {QueueNode *front;QueueNode *rear;}LinkQueueCar;void InitStack(SeqStackCar *s);int InitQueue(LinkQueueCar *Q);void Display(CarNode *p,int place);int Arrival(SeqStackCar *s,LinkQueueCar *LQ);void Leave1(SeqStackCar *s1,SeqStackCar *s2,LinkQueueCar *LQ); void Leave2(LinkQueueCar *LQ);void List1(SeqStackCar *s);void List2(LinkQueueCar *LQ);源文件#include "car.h"#include<iostream>using namespace std;int i=0;void InitStack(SeqStackCar *s){int i;s->top=0;for(i=0;i<=MAXSIZE;i++)s->data1[s->top]=NULL;}int InitQueue(LinkQueueCar *Q){Q->front=new QueueNode;if(Q->front!=NULL){Q->front->next=NULL;Q->rear=Q->front;return 1;}elsereturn 0;}void Display(CarNode *p,int place){int A1,A2,B1,B2,time;cout<<"请输入离开的时间:";cin>>p->leave.hour;cin>>p->leave.min;while(p->leave.hour<p->reach.hour||p->leave.hour>23){cout<<"error!"<<endl;cout<<"请输入离开的时间:";cin>>p->leave.hour;cin>>p->leave.min;}cout<<endl;cout<<"离开车辆的车牌号为:";cout<<p->num<<endl;cout<<"其到达时间为: "<<p->reach.hour<<":"<<p->reach.min<<endl;cout<<"其离开时间为: "<<p->leave.hour<<":"<<p->leave.min<<endl;A1=p->reach.hour;A2=p->reach.min;B1=p->leave.hour;B2=p->leave.min;time=(B1-A1)*60+(B2-A2);cout<<"该车停在停车场中的时间:"<<time<<"分钟!"<<endl;cout<<"应交费用为: "<<time*price<<"元!"<<endl;cout<<endl;}int Arrival(SeqStackCar *s,LinkQueueCar *LQ){CarNode *p;QueueNode *t;p=new CarNode;cout<<"请输入车牌号(例:A1234):";cin>>p->num;if(s->top<MAXSIZE){s->top++;cout<<"车辆在车场第"<<s->top <<"位置!"<<endl;cout<<"请输入到达时间:";cin>>p->reach.hour;cin>>p->reach.min;while(p->reach.hour<0||p->reach.hour>23||p->reach.min<0||p->reach.min>59) {cout<<"error!"<<endl;cout<<"请输入到达时间:";cin>>p->reach.hour;cin>>p->reach.min;}s->data1[s->top]=p;return 1;}else{cout<<"该车停在便道上!"<<endl;t= new QueueNode;t->data2=p;t->next=NULL;LQ->rear->next=t;LQ->rear=t;i++;cout<<"车辆在便道"<<i<<"个位置!"<<endl;return 1;}}void Leave1(SeqStackCar *s1,SeqStackCar *s2,LinkQueueCar *LQ) {int place;CarNode *p,*t;QueueNode *q;if(s1->top>0){while(1){cout<<"请输入车在车场的位置1--"<<s1->top<<":";cin>>place;if(place>=1&&place<=s1->top) break;}while(s1->top>place){s2->top++;s2->data1[s2->top]=s1->data1[s1->top];s1->data1[s1->top]=NULL;s1->top--;}p=s1->data1[s1->top];s1->data1[s1->top]=NULL;s1->top--;while(s2->top>=1){s1->top++;s1->data1[s1->top]=s2->data1[s2->top];s2->data1[s2->top]=NULL;s2->top--;}Display(p,place);if((LQ->front!=LQ->rear)&&s1->top<MAXSIZE){q=LQ->front->next;t=q->data2;s1->top++;cout<<"便道的"<<t->num<<"号车进入车场第"<<s1->top<<"位置!"<<endl;cout<<"请输入到达的时间:";cin>>t->reach.hour;cin>>t->reach.min;if(t->reach.hour<0||t->reach.hour>23||t->reach.min<0||t->reach.min>59){cout<<"error!"<<endl;cout<<"请输入到达时间:";cin>>t->reach.hour;cin>>t->reach.min;}LQ->front->next=q->next;if(q==LQ->rear)LQ->rear=LQ->front;s1->data1[s1->top]=t;delete q;}elsecout<<"便道里没有车!"<<endl;}elsecout<<"停车场里没有车!"<<endl;}void Leave2(LinkQueueCar *LQ){QueueNode *q;CarNode *t;if(LQ->front!=LQ->rear){q=LQ->front->next;t=q->data2;LQ->front->next=q->next;if(q==LQ->rear)LQ->rear=LQ->front;delete q;cout<<"便道上车牌号为"<<t->num<<"的车从便道上离开!"<<endl;}elsecout<<"便道里没有车!"<<endl;}void List1(SeqStackCar *s){int i;if(s->top>0){cout<<" 位置到达时间车牌号"<<endl;for(i=1;i<=s->top;i++){cout<<" "<<i<<" "<<s->data1[i]->reach.hour<<":"<<s->data1[i]->reach.min<<" "<<s->data1[i]->num<<endl;}}elsecout<<"停车场里没有车!"<<endl;}void List2(LinkQueueCar *LQ){QueueNode *p;p=LQ->front->next;if(LQ->front!=LQ->rear){cout<<"便道上车的车牌号为:"<<endl;while(p!=NULL){cout<<p->data2->num<<endl;p=p->next;}}elsecout<<"便道上没有车!"<<endl;}测试文件#include "car.h"#include<iostream>using namespace std;void main(){SeqStackCar s1,s2;LinkQueueCar LQ; int m;InitStack(&s1);InitStack(&s2);InitQueue(&LQ);while(1){cout<<"★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★"<<endl;cout<<"1.车辆到达2.离开停车场3.离开便道4.停车场列表5.便道列表6.退出系统"<<endl;cout<<"★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★"<<endl;cin>>m;switch(m){case 1:Arrival(&s1,&LQ);break;case 2:Leave1(&s1,&s2,&LQ);break;case 3:Leave2(&LQ);break;case 4:List1(&s1);break;case 5:List2(&LQ);break;case 6:exit(0);default: break;}}}（两运行结果：个图表联在一起）四、实验总结1．学会了栈和队列的综合使用，更加灵活运用栈和队列。
数据结构停车场收费系统管理实践报告
数据结构停车场收费系统管理实践报告停车场收费系统，这个话题一提起来，大家都不陌生。
说实话，谁没在大街小巷的停车场为了一块停车费而头疼过呢？尤其是在城市里，停车位稀缺，收费又是天价，弄得有时候进个停车场就像进了赌场，不知道到底会“亏”多少。
今天就聊聊我最近搞的一次“停车场收费系统管理实践”，说实话，整个过程就像是看一部高能悬疑片，既有趣又有点小紧张。
停车场的管理，说白了，就是得搞清楚停车位的利用率，然后合理收费，确保不亏本。
这听起来简单，但要做好，光靠脑袋里的想法可不行。
得用点“硬核”的东西，比如数据结构。
说到这里，很多人可能开始懵了：数据结构？那是啥？别担心，数据结构就是一堆有序的、按照特定规则组织起来的数据，简单点说，就是停车场的“内部管理”嘛。
比如你停车时，停车场会分配一个车位给你，那些车位就得按照一定的规则排序，不然你想找个位置就得像大海捞针一样。
我们做的这个停车场收费系统，首先就要搞清楚如何让停车位、车主和收费三个元素高效地“打交道”。
你想，假如停车场没有规则，那就乱套了，车位没人用，车主也找不到地方停车，收费自然就乱七八糟了。
搞清楚了这些，系统的基础架构就稳了。
说到收费，最常见的就是按时间收费。
我们通过程序算出来每个车主停车的时长，再按照预设的费用标准进行结算。
这里就得用到“链表”这个数据结构了。
车主的停车信息就像一颗颗“珠子”串在一起，每个珠子里面有车主的停车时间、车牌号、停车收费等数据。
如果一个车主停车时间很长，那收费就得按时间增加，反之，停车时间短，自然收费也少。
这种管理方式非常高效，不容易出错，而且能够快速计算每个车主的停车费。
哎，说实话，我一开始听到链表这俩字儿时，还挺疑惑的，感觉好像很“高大上”，但一弄明白后，才发现原来就是个简单又实用的东西，跟停车场的条理化管理一样，处理起来简洁又明了。
再说到停车收费的“智能化”，以前我们去停车场，不是排队等着人工收费，就是站在收费亭前一脸懵逼，不知道到底该怎么付。
数据结构实验报告模拟停车场管理(含代码)
模拟停车场管理班级：物联网姓名：XXX 学号：XXXXXXX 日期：4月9日一、需求分析1、程序的功能描述按照从终端输入的数据序列进行模拟管理。
1）狭道停车用栈来实现，并且用的顺序栈，等车位的便道用队列来实现，并用链式存储。
2）每一组输入信息包含三个数据项，汽车的“到达”和“离去”的信息，汽车牌照号码，汽车“到达”或“离去”的时刻。
3）对每一组输入数据进行操作后的输出信息为：若是车辆到达，则输出车辆在停车场内或便道上的停车位置；若是车子离去，则输出车辆在停车场内停留的时间和缴纳的费用。
（假设在便道等车的时间不收费）4）选作内容：（1）便道也是要收费的，仅仅比狭道收费便宜点。
（2）狭道上的车可以直接开走。
2、输入/输出的要求首先选择操作的模块，根据提示输入车牌和到达时间，程序会告知是否停满或者停车车位。
车牌为10个字符以内的字符串，时间的输入中间有冒号把时分隔开。
3、测试数据1 苏D543 1:101 苏Q123 1：201 苏D145 1：30二、概要设计1、本程序所用的抽象数据类型的定义typedef struct NODE{CarNode *stack[MAX+1];int top;}SeqStackCar;//狭道的堆栈顺序存储typedef struct car{CarNode *data;struct car *next;}QueueNode;//队列的链式存储typedef struct Node{QueueNode *head;QueueNode *rear;}LinkQueueCar;//便道上等候的队列定义2、主模块的流程及各子模块的主要功能○1车辆到达：int Arrival(SeqStackCar *Enter,LinkQueueCar *W)首先定义一个栈和队列的结构体指针为：*p , *t 。
然后申请一个车辆信息的内存空间，并把它赋给栈指针。
车辆到达时就输入车牌号，并通过if(Enter->top<MAX)来判断该车是进车场内还是进便道上，如果是进车场内就把top 加1，显示在车场内的位置，还要输入进车场的时间，然后把该节点进栈。
数据结构实践报告--停车场管理系统
数据结构实践报告--停车场管理系统河南财经政法⼤学集中实践报告院系：班级：指导⽼师：⼩组：⼩组成员：⽬录（⼀）设计⽬的 (3)（⼆）问题描述 (3)（三）概要设计 (4)（四）详细设计 (8)（五）调试分析 (9)（六）测试分析 (10)（七）⼼得体会 (11)（⼋）附录（源代码） (12)（⼀）设计⽬的1．通过课程设计，了解并掌握数据结构的设计⽅法，具备初步的独⽴分析和设计能⼒；2．通过课程设计，初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本⽅法和技能；3．通过课程设计，提⾼综合运⽤所学的理论知识和⽅法独⽴分析和解决问题的能⼒；4．通过课程设计，训练⽤系统的观点和软件开发⼀般规范进⾏软件开发，培养软件⼯作者所应具备的科学的⼯作⽅法和作风。
（⼆）问题描述及要求基本要求以栈模拟停车场，以队列模拟车场外的便道，按照从终端读⼊的输⼊数据序列进⾏模拟管理。
每⼀组输⼊数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码以及到达或离去的时刻。
对每⼀组输⼊数据进⾏操作后的输出信息为：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费⽤（在便道上停留的时间不收费）。
栈以顺序结构实现，队列以链表结构实现。
测试数据设n=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’表⽰到达（arrival）；‘D’表⽰离去（departure）；‘E’表⽰输出结束（end）。
实现提⽰需另设⼀个栈，临时停放为给要离去的汽车让路⽽从停车场退出来的汽车，也⽤顺序存储结构实现。
输⼊数据按到达或离去的时刻有序。
栈中每个元素表⽰⼀辆汽车，包含两个数据项：汽车的牌照号码和进⼊停车场的时刻。
此外还要实现：（1）两个栈共享空间，思考应开辟数组的空间是多少？（2）汽车可有不同种类，则他们的占地⾯积不同，收费标准也不同，如1辆客车和1.5辆⼩汽车的占地⾯积相同，1辆⼗轮卡车占地⾯积相当于3辆⼩汽车的占地⾯积。
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 为新的栈顶元素。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
..
《数据结构》课程设计报告
设计题目停车场管理系统
专业软件工程
班级12软工
姓名纪凯延
学号*********
完成日期2014.06.15
目录
1. 问题描述………………………………………………页码
2. 系统设计………………………………………………页码
3. 数据结构与算法描述…………………………………页码
4. 测试结果与分析………………………………………页码
5. 总结…………………………………………………页码
6. 参考文献………………………………………………页码附录程序源代码…………………………………………页码(要求：给出一级目录，宋体加粗，四号字,1.5倍行距。
)
课程设计题目
(要求：正文部分一律用小四号字，宋体，1.5倍行距。
一级标题靠左，四号加粗。
二级、三级标题靠左，小四加粗。
)
1.问题描述
设有一个可以停放n辆汽车的狭长停车场，它只有一个大门可以供车辆进出。
车辆按到达停车场时间的早晚依次从停车场最里面向大门口处停放(最先到达的第一辆车放在停车场的最里面)。
如果停车场已放满n 辆车，则后来的车辆只能在停车场大门外的便道上等待，一旦停车场有车开走，则排在便道上的第一辆车就进入停车场。
停车场如有某辆车要开走，在它之后进入停车场的车都必须先退出停车场为它让路，待其开出停车场后，这些车辆再依原来的次序进场。
每辆车在离开停车场时，都应根据它在停车场停留的时间长短交费。
如果停留在便道上的车未进停车场就要离去，允其离去，不收停车费，并且仍然保持在便道上等待的车辆的次序。
编制一程序模拟该停车场的管理。
2. 系统设计
2.1 设计目标
•要求程序输出每辆车到达后的停车位置(停车场或便道上)，以及某辆车离开停车场时应交纳的费用和它在停车场停留的时间。
•
2.2 设计思想
此停车场管理系统是在一个狭长的通道上的，而且只有一个大门可以供车辆进出，并且要实现停车场某辆车要离开时，在它之后进入停车场的车都必须先退出停车场为它让路，待其开出停车场后，这些辆再依原来的次序进场的功能，就可以设计两个堆栈，其中一个堆栈用来模拟停车场，另一个堆栈用来模拟临时停车场，该临时停车场用来存放当有车辆离开时，原来停车场为其让路的车辆。
至于当停车场已满时，需要停放车辆的通道可以用一个链队列来实现。
当停车场开走一辆车时，通道上便有一辆车进入停车场，此时只需要改变通道上车辆结点的连接式就可以了，使通道上第一辆车进入停车场这个堆栈，并且使通道上原来的第二辆车成为通道上的第一辆车，此时只需将模拟通道的链队列的头结点连到原来的第二辆车上就可以了。
2.3 系统模块划分（要给出流程图）
3. 数据结构与算法描述
(1) 功能模块说明：停车场管理系统含有三个模块，即：车辆到达、离开、列
表显示
（2）以模块为单位分析算法
1、“到达”模块：到达时有两种情况，即车场是否满，未满则直接进入停车场；满时，到便道等待。
如图2。
2.“离开”模块：离开时，当车库为空时，提示没有车，结束；否则车辆离开。
如
3. “显示”模块：显示模块有两个显示选项，即：车场与便道。
如图4。
4. 测试结果与分析（可将测试过程抓图说明）
测试输入
服务选择车牌号/车位到达/离开时间
1 HN001 10：10
2 1 01：00
分析
此停车管理系统基本可能实现一个小的停车场的管理，其“到达”与“离开”法都相对比较完整，以及结算清单明了。
尽管在时间先后上有出现混乱，但当其用到实际应用时，那个时间先后就可以避免了。
但在输入数据时，要按照格的格式输入，否则有可能出现死去或崩溃。
若本系统能加上保存功能就更好了，因为一个系统在使用过程中总会关机等，而此系统的缺点却是没有保存功能，关闭之后就要重新建立了。
会慢慢完善。
5. 总结
此停车管理系统基本可能实现一个小的停车场的管理，其“到达”与“离开”法都相对比较完整，以及结算清单明了。
尽管在时间先后上有出现混乱，但当其用到实际应用时，那个时间先后就可以避免了。
但在输入数据时，要按照格的格式输入，否则有可能出现死去或崩溃。
若本系统能加上保存功能就更好了，因为一个系统在使用过程中总会关机等，而此系统的缺点却是没有保存功能，关闭之后就要重新建立了。
会慢慢完善。
6. 参考文献（包括书籍、论文、网络资料等）
[1] 振安等.《C++程序设计课程设计》.北京：机械工业出版社，2004.12.
[2] 武法提.《基于网络的学习环境的设
计》. .resource.ahedu./edu_lunwen/index 2004.10.6
（要求：小四号字，宋体，1.5倍行距。
按作者、书名、地点、出版社、出版时间格式逐一列出。
参考网上文章时，格式为：作者、文章名称、网址、时间。
)
附录程序源代码。