C C++ 停车场管理系统
停车场管理系统——C语言
停车场管理系统【要求】(1)有一个两层的停车场,每层有6个车位,当第一层车停满后才允许使用第二层(停车场可用一个二维数组实现,每个数组元素存放一个车牌号),每辆车的信息包括车牌号、层号、车位号、停车时间共4项,其中停车时间按分钟计算。
(2)假设停车场初始状态为第一层已经有4辆车,其车位号依次为1~4,停车时间依次为20,15,10,5,即先将这4辆车的信息存入文件car.dat中(数组的对应元素也要进行赋值)。
(3)停车操作:当一辆车进入停车场时,先输入其车牌号,再为它分配一个层号和一个车位号(分配前先查询车位的使用情况,如果第一层有空位则必须停在第一层),停车时间设为5,最后将新停入的汽车的信息添入文件car。
dat中,并将在此之前的所有停车时间加5。
(4)收费管理(取车):当有车离开时,输入其车牌号,先按其停车时间计算费用,每5分钟0.2元(停车费用可设置一个变量进行保存),同时从文件car。
dat 中删除该车的信息,并将该车对应的车位设置为可用状态(即二维数组对应元素清零),按用户的选择来判断是否要输出停车收费的总计。
(5)输出停车场中全部车辆的信息.(6)退出系统。
【提示】(1)需求分析:车辆信息要用文件储存,提供文件的输入输出操作;当车要离开时要删除文件中该车的信息,因而要提供文件的删除操作;另外还要用键盘式菜单实现功能选择.(2)总体设计:整个管理系统可设计为停车模块、取车模块、车辆信息浏览模块.二、总体设计根据上面的需求分析,可以将这个系统的设计分为四大模块(如图2—1):停车、取车、车辆信息浏览、退出。
其中主要功能是停车、取车、车辆信息浏览三个模块。
图2—1系统功能模块图根据模块图可画出总的流程图(图2—2)图2—2 总流程图三、详细设计1、车辆信息车辆信息包括车牌号、层号、车位号、停车时间,将这四类数据组合成结构体car,以便于引用。
【程序】struct car{int carnumber;int floor;int position;int time;}car[12];2、车位信息由于停车场有两层,每层六个车位,故车位信息可由一个二维数组park[2][6]表示,注意停车场中已经停放了4辆车,设这四辆车的车牌号为6840,4167,3548,9201。
停车场管理系统—C语言课程设计.doc
停车场管理系统1题目要求设有一个可以停放n 辆汽车的狭长停车场,它只有一个大门可以供车辆进出。
车辆按到达停车场时间的早晚依次从停车场最里面向大门口处停放(最先到达的第一辆车放在停车场的最里面)。
如果停车场已放满n 辆车,则后来的车辆只能在停车场大门外的便道上等待,一旦停车场内有车开走,则排在便道上的第一辆车就进入停车站。
停车站内如有某辆车要开走,在它之后进入停车场的车都必须先退出停车站为它让路,待其开出停车场后,这些车辆再依原来的次序进场。
每辆车在离开停车场时,都应根据它在停车场内停留的时间长短交费。
如果停留在便道上的车未进停车场就要离去,允许其离去,不收停车费,并且仍然保持在便道上等待的车辆的次序。
编制一程序模拟该停车场的管理。
【基本要求】要求程序输出每辆车到达后的停车位置(停车场或便道上),以及某辆车离开停车场是的停车时间及它应该交的费用。
2需求分析根据题目要求,因为停车场是一个单条的序列,可以用结构体实现;在程序中,需要知道每辆来车的具体停放位置,应提供提示、查找、标记工作。
车辆离开要计时计费。
另外,每天开始时,停车场要初始化。
3总体设计这个系统可以分为:初始化、有车进入、有车离开、退出四个模块。
4详细设计main()函数体内包含了界面选则部分menu(),并单独抽出来作为一个独立函数,目的在于系统执行每部分模块后能够方便返回到系统界面。
即main()函数写为 如下:void main()/*主函数*/ { menu();/*菜单函数*/ }菜单函数: void menu() { int n,w; do { puts("\t\t**************MENU**************\n\n"); puts("\t\t\t 1.初始化"); puts("\t\t\t 2.有车进入"); puts("\t\t\t 3.有车离开"); puts("\t\t\t 4.退出"); puts("\n\n\t\t*********************************\n"); printf("Please choice your number(1-4): [ ]\b\b"); scanf("%d",&n); if(n<1||n>4) /*对选择的数字作判断*/ { w=1; getchar(); } else w=0; }while(w==1); switch(n) { case 1:chushi();break; /*初始化函数*/ case 2:jinru();break; /*车辆进入函数*/case 3:likai();break;/*车辆离开函数*/case 4:exit(0);/*退出*/}}初始化模块设计:【需求分析】该模块是将每一天开始的停车场内和便道车位清零。
停车场管理c语言pta
停车场管理c语言pta
停车场管理系统是一个常见的项目,可以使用C语言来实现。
这个系统可以包括车辆进入和离开的记录、收费计算、停车位管理
等功能。
在PTA(Programming Teaching Assistant)上实现停车
场管理系统可以通过以下步骤进行:
1. 数据结构设计,首先,需要设计合适的数据结构来存储车辆
信息、停车位状态等。
可以使用结构体来表示车辆信息,使用数组
或链表来管理停车位的状态。
2. 车辆进入和离开记录,编写函数来处理车辆进入和离开的记录,包括记录车辆的进入时间、离开时间,以及相应的费用计算。
3. 收费计算,根据停车时间和车辆类型(例如小型车、大型车)来计算停车费用。
可以设置不同的收费标准,并编写函数来进行费
用计算。
4. 停车位管理,设计算法来管理停车位的分配和释放,确保停
车场的停车位能够合理利用。
5. 用户界面,可以使用C语言的控制台来实现简单的用户界面,让用户可以输入车辆信息、查询停车费用等操作。
在PTA上实现停车场管理系统需要考虑到输入输出的格式,以
及对各种异常情况的处理。
同时,还需要编写测试用例来验证程序
的正确性和稳定性。
总之,通过合理的数据结构设计、功能模块划分和用户界面实现,可以在PTA上使用C语言实现停车场管理系统。
这样的项目可
以帮助学生加深对C语言的理解,并锻炼编程能力。
停车场管理系统代码
// 1、停车场管理.cpp : Defines the entry point for the console application. //#include "stdafx.h"#include <conio.h>#include <malloc.h>#include <stdio.h>#include <stdlib.h>#include <windows.h>// 清空当前屏幕#define ClearScreen() system( "cls" )//设置背景前景颜色//#define setcolor() system("color 2f")// 显示字符串 szPrompt 并等待用户按下任意键#define Pause( szPrompt ) printf( "%s", szPrompt ),getch()typedef struct carinformation // 车辆信息{char szRegistrationMark[64]; // 车牌号char szArrivalTime[16]; // 到达时间char szEntranceTime[16]; // 进入停车场(开始计费)时间char szDepartureTime[16]; // 离开时间} TCARINFORMATION, *LPTCARINFORMATION;typedef struct carstack{LPTCARINFORMATION lpCarInformation; // 车辆信息int nTop; // 栈顶元素下标int nStackSize; // 栈容量} TCARSTACK, *LPTCARSTACK;// 初始化栈 lpCarStack, 将其容量设置为 nSizevoid InitStack( LPTCARSTACK &lpCarStack, int nSize ){lpCarStack = ( LPTCARSTACK ) malloc( sizeof ( TCARSTACK ) );lpCarStack->lpCarInformation = ( LPTCARINFORMATION ) malloc( nSize * sizeof ( TCARINFORMATION ));lpCarStack->nTop = -1;lpCarStack->nStackSize = nSize;}// 车辆信息 carinfo 入栈 lpCarStackvoid Push( LPTCARSTACK &lpCarStack, TCARINFORMATION carinfo ) {lpCarStack->nTop++;lpCarStack->lpCarInformation[lpCarStack->nTop] = carinfo;}// 车辆信息从栈 lpCarStack 中弹出并存入 carinfovoid Pop( LPTCARSTACK &lpCarStack, TCARINFORMATION &carinfo ) {carinfo = lpCarStack->lpCarInformation[lpCarStack->nTop];lpCarStack->nTop--;}// 若栈 lpCarstack 空,返回 TRUE;否则,返回 FALSEBOOL IsStackEmpty( LPTCARSTACK lpCarStack ){return lpCarStack->nTop == -1;}// 若栈 lpStackFull 满,返回 TRUE;否则,返回 FALSEBOOL IsStackFull( LPTCARSTACK lpCarStack ){return lpCarStack->nTop == ( lpCarStack->nStackSize - 1 );}// 销毁栈 lpCarStack,将指针 lpCarStack 置为 NULLvoid DestroyStack( LPTCARSTACK &lpCarStack ){free( lpCarStack->lpCarInformation );free( lpCarStack );lpCarStack = NULL;}typedef struct carnode // 链队结点信息{TCARINFORMATION carinfo; // 车辆信息struct carnode *lpNext; // 指向下一个元素的指针} TCARNODE, *LPTCARNODE;typedef struct carqueue // 链队{LPTCARNODE lpHead; // 头结点LPTCARNODE lpRear; // 指向当前队尾的指针int nEffectiveSize; // 当前队中元素个数} TCARQUEUE, *LPTCARQUEUE;// 初始化链队 lpCarQueuevoid 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;}// 车辆信息 carinfo 入队 lpCarQueuevoid EnQueue( LPTCARQUEUE &lpCarQueue, TCARINFORMATION carinfo ) {LPTCARNODE lpCarNode = ( LPTCARNODE ) malloc( sizeof( carnode ) );lpCarNode->carinfo = carinfo;lpCarNode->lpNext = NULL;lpCarQueue->lpRear->lpNext = lpCarNode;lpCarQueue->lpRear = lpCarQueue->lpRear->lpNext;lpCarQueue->nEffectiveSize++;}// 队头元素从链队 lpCarQueue 中出队并存入 carinfovoid DeQueue( LPTCARQUEUE &lpCarQueue, TCARINFORMATION &carinfo ) {LPTCARNODE lpTemp = lpCarQueue->lpHead->lpNext;carinfo = lpTemp->carinfo;lpCarQueue->lpHead->lpNext = lpTemp->lpNext;free( lpTemp );lpCarQueue->nEffectiveSize--;}// 若链队 lpCarQueue 为空,返回 TRUE;否则,返回 FALSEBOOL IsQueueEmpty( LPTCARQUEUE lpCarQueue ){return lpCarQueue->nEffectiveSize == 0;}// 销毁链队 lpCarQueuevoid DestroyQueue( LPTCARQUEUE &lpCarQueue ){LPTCARNODE lpNextCarNode = NULL;for ( LPTCARNODE lpCarNode = lpCarQueue->lpHead; lpCarNode != NULL; lpCarNode = lpNextCarNode ){lpNextCarNode = lpCarNode->lpNext;free( lpCarNode );}free( lpCarQueue );lpCarQueue = NULL;}// 将字符串时间格式转换为数字(分钟)格式,例如 12:36 将被转换为 756 ( 12 * 60 + 36 )int ConvertTimeFormat( char *lpTime ){int nHour = 0;int nMinute = 0;sscanf( lpTime, "%d:%d", &nHour, &nMinute );return nHour * 60 + nMinute;}// 根据在停车场内的停留时间 nContinuanceMinutes (分钟)计算费用double CalculateExpense( int nContinuanceMinutes ){return nContinuanceMinutes * ( 5.0 / 60 );}int main( void ){// setcolor();int nParkCapability = 0; // 停车场容量putchar( '\n' );printf( "请输入停车场容量:" );scanf( "%d", &nParkCapability );LPTCARSTACK lpCarStack = NULL; // 停车场,用栈模拟豫 InitStack( lpCarStack, nParkCapability );LPTCARQUEUE lpCarQueue = NULL; // 便道,用链队模拟 InitQueue( lpCarQueue );char cCommandType = NULL; // 命令类型char szUserInput[128] = { NULL }; // 用户输入do{ClearScreen();//setcolor();putchar( '\n' );puts( "--------------------" );puts( "[命令类型]" );puts( "A - 车辆到达" );puts( "D - 车辆离开" );puts( "E - 停止输入" );puts( "O - 显示当前停车场和便道使用情况" );putchar( '\n' );puts( "例:" );puts( "A,鄂A3926,13:33" );puts( "D,鄂A3926,14:44" );puts( "E" );puts( "O" );putchar( '\n' );printf( "请输入命令:" );scanf( "%s", szUserInput );puts( "--------------------" );char szCarInformation[128] = { NULL };sscanf( szUserInput, // 将命令类型与车辆信息分开存放"%c,%s",&cCommandType, // 用户输入的前半部分,即命令类型szCarInformation // 用户输入的后半部分,即车辆信息);char *lpCommaLocation = NULL; // 车辆信息字符串中的逗号位置for ( lpCommaLocation = szCarInformation; *lpCommaLocation != '\0'; lpCommaLocation++ ){if ( *lpCommaLocation == ',' ){break;}}*lpCommaLocation = '\0';TCARINFORMATION carinfo = { NULL }; // 存储本次用户输入的车辆信息 strcpy( carinfo.szRegistrationMark, szCarInformation );if ( cCommandType == 'A' ){strcpy( carinfo.szArrivalTime, lpCommaLocation + 1 );if ( FALSE == IsStackFull( lpCarStack ) ){strcpy( carinfo.szEntranceTime, carinfo.szArrivalTime ); Push( lpCarStack, carinfo );printf( "已进入停车场第 %d 个车位\n",lpCarStack->nTop + 1);printf( "车牌号:\t\t%s\n", carinfo.szRegistrationMark ); printf( "进入时间:\t%s\n", carinfo.szEntranceTime );puts( "是否收费:\t是" );}else{EnQueue( lpCarQueue, carinfo );printf( "停车场已满,已停放在便道的第 %d 个车位\n",lpCarQueue->nEffectiveSize);printf( "车牌号:\t\t%s\n", carinfo.szRegistrationMark ); printf( "停放时间:\t%s\n", carinfo.szArrivalTime );puts( "是否收费:\t否" );}}else if ( cCommandType == 'D' ){strcpy( carinfo.szDepartureTime, lpCommaLocation + 1 );LPTCARSTACK lpTempCarStack = NULL;InitStack( lpTempCarStack, nParkCapability );TCARINFORMATION carinfoOut = { NULL };BOOL bIsCarFound = FALSE;while ( FALSE == IsStackEmpty( lpCarStack ) ){Pop( lpCarStack, carinfoOut );if ( 0 != strcmp( carinfoOut.szRegistrationMark, carinfo.szRegistrationMark ) ) {Push( lpTempCarStack, carinfoOut );}else{bIsCarFound = TRUE;break;}}while ( FALSE == IsStackEmpty( lpTempCarStack ) ){TCARINFORMATION tempcarinfo = { NULL };Pop( lpTempCarStack, tempcarinfo );Push( lpCarStack, tempcarinfo );}if ( FALSE == bIsCarFound ){printf( "车牌号为 %s 的车未进入停车场.\n", carinfo.szRegistrationMark ); Pause( "--------------------\n按任意键输入下一条信息...\n" );continue;}strcpy( carinfoOut.szDepartureTime, carinfo.szDepartureTime );int nEntranceTime = ConvertTimeFormat( carinfoOut.szEntranceTime ); int nDepartureTime = ConvertTimeFormat( carinfoOut.szDepartureTime ); int nContinuanceMinutes = nDepartureTime - nEntranceTime;printf( "计费时段:\t%s - %s (共 %d 分钟)\n",carinfoOut.szEntranceTime,carinfoOut.szDepartureTime,nContinuanceMinutes);double rExpense = CalculateExpense( nContinuanceMinutes );printf( "应交纳的费用:\t%.1lf 元\n", rExpense );if ( FALSE == IsQueueEmpty( lpCarQueue ) ){TCARINFORMATION tempcarinfo = { NULL };DeQueue( lpCarQueue, tempcarinfo );strcpy( tempcarinfo.szEntranceTime, carinfoOut.szDepartureTime );Push( lpCarStack, tempcarinfo );puts( "--------------------" );printf( "停放在便道的第 1 个车位,车牌号为 %s 的车已进入停车场\n",tempcarinfo.szRegistrationMark);}}else if ( cCommandType == 'E' ){puts( "********************" );puts( " :吴远彦 \n" );puts( "学号: \n" );puts( "********************" );break;}else if ( cCommandType == 'O' ){ClearScreen();//setcolor();putchar( '\n' );puts( "[停车场使用情况]\n" );puts( "[车位]\t[车牌号]\t[到达时间]\t[进入(开始计费)时间]\n"); for ( int i = 0; i <= lpCarStack->nTop; i++ ){printf( "%d\t%s\t\t%s\t\t%s\n",i + 1,lpCarStack->lpCarInformation[i].szRegistrationMark,lpCarStack->lpCarInformation[i].szArrivalTime,lpCarStack->lpCarInformation[i].szEntranceTime);}putchar( '\n' );putchar( '\n' );putchar( '\n' );puts( "[便道使用情况]\n" );puts( "[车位]\t[车牌号]\t[到达时间]\t[进入(开始计费)时间]\n");int nNum = 0;for ( LPTCARNODE lpCarNode = lpCarQueue->lpHead->lpNext;lpCarNode != NULL; lpCarNode = lpCarNode->lpNext ){nNum++;printf( "%d\t%s\t\t%s\t\t%s\n",nNum,lpCarNode->carinfo.szRegistrationMark,lpCarNode->carinfo.szArrivalTime,lpCarNode->carinfo.szEntranceTime);}putchar( '\n' );}else{puts( "输入信息有误.第一个字符只能为 'A' 或 'D' 或 'E' 或 'O' (区分大小写)." ); }Pause( "--------------------\n按任意键输入下一条信息.\n" );} while ( TRUE );DestroyStack( lpCarStack );DestroyQueue( lpCarQueue );Pause( "\n按任意键退出程序...\n" );return 0;}。
数据结构c语言版课程设计停车场管理系统
课程设计:停车场c语言版本的数据结构课程设计,要求用栈模拟停车场,用队列模拟便道,实现停车场的收费管理系统停车场停满车后车会停在便道上面下面附上源码,vc:(下编译#include 〈stdio。
h>//#include 〈stdlib。
h〉//malloc#include 〈time。
h〉//获取系统时间所用函数#include <conio.h> //getch()#include 〈windows。
h〉//设置光标信息mallco #define MaxSize 5 /*定义停车场栈长度*/#define PRICE 0。
05 /*每车每分钟收费值*/#define BASEPRICE 0。
5 //基础停车费#define Esc 27 //退出系统#define Exit 3 //结束对话#define Stop 1 //停车#define Drive 2 //取车int jx=0,jy=32;//全局变量日志打印位置typedef struct{int hour;int minute;}Time,*PTime;/*时间结点*/typedef struct /*定义栈元素的类型即车辆信息结点*/{int num ;/*车牌号*/Time arrtime;/*到达时刻或离区时刻*/}CarNode;typedef struct /*定义栈,模拟停车场*/{CarNode stack[MaxSize];int top;}SqStackCar;typedef struct node /*定义队列结点的类型*/{int num; /*车牌号*/struct node *next;}QueueNode;typedef struct /*定义队列,模拟便道*/ {QueueNode *front,*rear;}LinkQueueCar;/*函数声明*/PTime get_time();CarNode getcarInfo();void qingping(int a);void gotoxy(int x,int y);void printlog(Time t,int n,int io,char ab,int po,double f);void printstop(int a,int num,int x0,int y0);void printleave(int a,int po,int num);/*初始化栈*/void InitSeqStack(SqStackCar *s){s—〉top=—1;}/* push入站函数*/int push(SqStackCar *s,CarNode x) //数据元素x入指针s所指的栈if(s->top==MaxSize-1)return(0); //如果栈满,返回0 else{s—〉stack[++s-〉top]=x; //栈不满,到达车辆入栈return(1);}}/*栈顶元素出栈*/CarNode pop(SqStackCar *s){CarNode x;if(s->top〈0){x。
PLC课程设计(停车场车位控制 )
目录1 引言12 概述23 系统总体方案设计 ---------------------------------------------------- 33.1 主电路的设计43.2 控制电路的设计43.2.1 PLC概述43.2.2 PLC选型63.2.3系统变量定义及分配表83.2.4系统接线图设计-------------------------------------------- 94 控制系统设计124.1控制程序流程图设计124.2控制程序设计思路125 系统调试及结果分析155.1 系统调试及解决的问题----------------------------------------- 155.2 结果分析--------------------------------------------------------- 15 完毕语--------------------------------------------------------------------- 16 参考文献17附录一: 梯形图19附录一: 程序指令201 引言随着进口汽车大量涌入和国内汽车工业的不断开展,大中城市的汽车数量剧增,从而引发了停车管理问题。
近几年,我国的停车场管理技术不断完善,计算机技术、通信技术、网络技术的开展又使停车场管理的系统功能得以提高。
现在小区停车场管理系统重点要做到准确指示车辆进出,车辆进入时给与司机准确的车位数量与具体位置,车辆进入后,记录车辆数量,车辆离开时,减少车辆数量。
车辆进出指示可完全由PLC作为中央控制来处理,停车场空位指示可利用价格较不高的数码管显示。
停车场车位管理系统,它由固定在停车场中的管理控制器、埋设在车位处的电动车位锁及移动控制器相互连接构成;管理控制器包括传感器接收模块、逻辑控制电路及驱动控制电路;电动车位锁的电源端与驱动控制电路的电源输出端连接;移动控制器中设有数据读写控制电路、无线遥控发射模块及电池,该无线遥控发射模块通过移动控制器外部设置的遥控天线与管理控制器的接收天线进展无线信号连接,具有极大的实用价值。
C语言课程设计报告停车场管理系统
算法与数据结构课程设计题目:停车场管理专业班级:软件四班姓名:学号:指导教师:成绩:______________目录一、题目及要求 (2)二、题目分析 (3)三、数据结构说明 (4)四、各函数算法分析 (5)(1)主函数 (5)(2)车辆到达函数 (7)(3)车辆离开函数 (8)(4)列表显示函数 (10)五、程序测试 (14)(1)测试信息对错误的处理 (14)(2)列表显示 (15)(3)同时输出等待的提示作息 (16)(4)计算它们的应交费用 (17)六、课程设计感悟与收获 (18)七、源代码 (19)八、参考文献 (25)一、题目及要求[要求]设有一个可以停放n辆汽车的狭长停车场,它只有一个大门可以供车辆进出。
车辆按到达停车场时间的早晚依次从停车场最里面向大门口停放(最先到达的第一辆车放在停车场的最里面)。
如果停车场已放满n辆车,则后来的车辆只能在停车场大门外的便道上等待,一旦停车场内有车开走,则排在便道上的第一辆国就进入停车场。
停车场内如有某辆车要走,在它之后进来的车都必须退出停车场为它让路,待其开出停车场后,这些车辆再依原来的次序进场。
每辆车在离开停车场时,都应根据它在停车场内停留的时间长短交费。
如果停留在便道上的车未进停车场就要离去,允许其离去,不收停车费,并且其他在便道上等待的车辆的次序不变。
编制一程序模拟停车场管理。
[提示]汽车的模拟输入信息格式可以是:(到达/离去,汽车牌照号码,到达/离去时刻)。
例如:(’A’,1,5)表示1号牌照车在5这个时刻到达,而(’D’,5,20)表示5号牌照车在20这个时刻离去,整个程序可以在输入信息为(’E’,0,0)时结束。
基本要求:要求程序输出每辆车到达后的停车位置(停车场或便道上),以及某辆车离开停车场时应交的费用和它在停车场内停留的时间。
根据题目要求,停车场可以用一个长度为n的堆栈来模拟。
由于停车场内如有某辆车要开走,在它之后进来的车都必须先退出停车场为它让路,待其开出停车场后,这些车辆再依原来的次序进场。
CW停车场管理系统使用手册
停车场管理系统使用手册PK-CPW10.5深圳市披克科技有限公司SHENZHEN PEAKE TECHNOLOGY CO., LTD.第一章系统简介1.1停车场管理系统简介停车场管理系统是非接触式IC卡技术应用一卡通系统之一,该系统集非接触式IC卡技术、计算机网络、视频监控、图象识别处理及自动控制技术于一体。
实现了停车场(库)的全自动化管理,包括车辆出入控制、车型、车牌校对、车位检索、引导、停车费用收取等自动管理。
具有套餐卡、临时卡、特权卡、管理卡等各种收费管理方式,具有自动出卡或自动出纸票、中英文LED显示、语音提示、对讲系统、车牌识别、图象对比、自动起落闸、防闸车、防闸人等功能。
长距离微波卡可实现无人值守,车辆通行时不需打开车窗,自动读卡开启道闸。
车位引导系统利用超声波检测器检测车位使用情况,实时告知空闲车位的位置及指引停车路线。
广泛应用于智能大厦、智能小区的各种场合。
1.2停车场管理系统组成标准停车场管理系统由入口机、出口机、电动道闸、车辆检测器、压力电波、摄像机、射灯、图像采集卡、停车场系统管理软件等组成。
入口机包含读卡器、控制器、信息显示屏、对讲分机、语音提示、车辆检测器、自动出卡机或出票机等出口机包含读卡器、控制器、信息显示屏、对讲分机、语音提示、车辆检测器、自动收卡机等,如下图所示:(1)读卡器读取IC卡的卡号、出入场时间等信息,送入控制器◆临时卡选择短距离非接触式IC卡读卡器,读卡距离不小于5cm◆长期卡可远距离微波读卡器,感应距离为3-4米或以上(2)停车场控制器接收来自读卡器的IC卡信息,存储权限及各种信息记录,做出判断,控制输出开闸、显示等信号,并完成控制器与电脑之间的信息交换(包括上传相关信息至电脑及从电脑下载数据至控制器)。
(3)电动道闸用于阻挡无权限的车辆、放行有效车辆(4)车辆检测器及地感线圈自动检测车辆的有无,实现道闸自动落杆以及相关操作信息(5)压力电波(可选)利用压力传感器检测车辆和行人,达到对人、车的安全要求(6)自动出卡机(可选)对于入口临时卡的发放,自动弹出临时车使用的IC卡(7)自动收卡机(可选)对于出口临时卡在管理中心缴完费之后,在无人值守的出口通过收卡机识别已缴费的临时卡自动放行并回收卡片(8)自动出票机(可选)对于入口临时票的发放,自动打印出临时车使用的条码票据(9)信息显示屏显示时间、收费金额、卡有效期、车位以及停车场其他相关信息(10)语音系统提示车辆进出场的读卡操作、收费等,如正常操作可提示请读卡、收费金额、有效期等相关信息,误操作或非法操作作出相应提示(11)对讲系统在管理中心安装对讲主机,各出入口安装对讲分机,保证各出入口和管理中心的联络(12)摄像机自动摄取车辆外型、颜色、车牌号码等图像信息,出场时将出口摄取的车辆图象与入口图象进行比较,信息一致时,车辆放行,确保车辆安全(13)发卡机读写IC卡内信息(14)HUB(或网络扩展器)TCP/IP网络控制器通过网络交换机或HUB实现互联及连接服务器,而RS-485/422控制器则通过网络扩展器(RS-485/422转换成RS-232)连接服务器(15)系统管理软件通过软件实现停车场系统相关功能(如控制进出、收费、图像对比、授权、统计管理)1.3停车场管理系统结构及功能1.3.1停车场管理系统结构1.3.2停车场管理系统功能◆软件的人机界面友好,易于操作,具有较强的抗外界干扰能力;◆在系统脱机、联网时,系统软件能够自动侦测,自动调整运行;◆可对用户权限、用户档案、操作密码、系统日志、记录保留时间等进行管理和更改;◆能自动记录操作员操作日志,包括:操作员编号、操作员姓名、操作类型、操作时间、操作对象、操作内容、操作结果;◆可设置参数包括停车场的车位数量、停车场名称、地址、出入口数量、收费规则等。
停车场管理系统(数据结构。C语言版)
//---------------基本操作---------------------
Status InitQueue(LinkQueue &Q){
//构造空队列Q
Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
#define FEIYONG 0.05 //停车费用单价
#define MAXSIZE 5 //停车场容量
//--------------系统库函数------------------
#include "stdlib.h"
//--------------通用变量、常量、类型声明------------------
//插入元素e为新的队尾元素
QueuePtr 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;
}//DestroyStack
停车场管理系统C语言实现
一.问题描述1.实验题目:设停车场是一个可停放n 辆汽车的狭长通道,且只有一个大门可供汽车进出;汽车在停车场内按车辆到达时间的先后顺序,依次由北向南排列大门在最南端,最先到达的第一辆车停放在车场的最北端;若停车场内已经停满n辆车,那么后来的车只能在门外的便道上等候;一旦有车开走,则排在便道上的第一辆车即可开入;当停车场内某辆车要离开时,在它之后进入的车辆必须先退出车场为它让路,待该辆车开出大门外,其他车辆再按原次序进入车场;每辆停放在车场的车在它离开停车场时必须按它停留的时间长短缴纳费用;试为停车场编制按上述要求进行管理的模拟程序;要求:根据各结点的信息,调用相应的函数或者语句,将结点入栈入队,出栈或者出队;二.需求分析1.程序所能达到的基本可能:程序以栈模拟停车场,以队列模拟车场外的便道,按照从终端读入数据的序列进行模拟管理;栈以顺序结构实现,队列以链表结构实现;同时另设一个栈,临时停放为给要离去的汽车让路而从停车场退出来的汽车;输入数据按到达或离去的时刻有序;当输入数据包括数据项为汽车的“到达”‘A’表示信息,汽车标识牌照号以及到达时刻时,应输出汽车在停车场内或者便道上的停车位置;当输入数据包括数据项为汽车的“离去”‘D’表示信息,汽车标识牌照号以及离去时刻时,应输出汽车在停车场停留的时间和应缴纳的费用便道上停留的时间不收费;当输入数据项为‘P’,0,0时,应输出停车场的车数;当输入数据项为‘W’, 0, 0时,应输出候车场车数;当输入数据项为‘E’, 0, 0,退出程序;若输入数据项不是以上所述,就输出"ERROR";2.输入输出形式及输入值范围:程序运行后进入循环,显示提示信息:“Please input the state,number and time of the car:”,提示用户输入车辆信息“到达”或者“离开”,车牌编号,到达或者离开的时间;若车辆信息为“到达”,车辆信息开始进栈模拟停车场,当栈满,会显示栈满信息:“The parking place is full”,同时车辆进队列模拟停车场旁便道,并显示该进入便道车辆的车牌编号,让用户知道该车的具体位置;若车辆信息为“离开”,会显示该车进入停车场的时间以及相应的停车费用,若该车较部分车早进停车场,这部分车需先退出停车场,暂时进入一个新栈为其让道,会显示进入新栈的车辆的车牌编号及其入停车场的时间,当待离开车离开停车场后,这部分车会重新进入停车场,同时便道上的第一辆车进入停车场;若输入‘P ’,0,0,会显示停车场的车数;若输入‘W ’,0,0,会显示便道上的车数;若输入‘E ’,0,0,程序会跳出循环,同时程序结束;若输入为其他字母,程序会显示“ERROR ”报错;若便道上没有车辆停靠,会显示便道为空的信息:用户每输入一组数据,程序就会根据相应输入给出输出;输入值第一个必须为字母,后两个为数字;3.测试数据要求:用户输入字母时,输入大写或小写,都可以被该程序识别,正常运行;但要求用户输入数据时,三个数据项之间必须用逗号相分隔开;三.概要设计为了实现上述功能,该程序以栈模拟停车场以及临时停放为给要离去的汽车让路而从停车场退出来的汽车的场地,以队列模拟车场外的便道,因此需要栈和队列这两个抽象数据类型;1.栈抽象数据类型定义:ADT SqStack{数据对象:D={char d c b a d c b a i i i i i i i i ∈∈∈∈int,int,int,|,,,, i=1,2,3....,n,n 0≥}数据关系:R={i i i d b a ,,|∈i i i d b a ,,D,∈i i i d b a ,,struct car};基本操作:Judge_Outputs,q,r ;列抽象数据类型定义:ADT LinkQueue{数据对象:D={∈i i i i a c b a |,,Qnode ,∈i b Qnode,int ∈i c ,i=1,2,3....,n,n 0≥};数据关系:R=φ;基本操作:Judge_Outputs,q,r;要算法流程图:I.Judge_Output算法流程图:II.A_cars算法流程图:III.D_cars算法流程图:4.本程序保护模块:主函数模块栈单元模块:实现栈的抽象数据类型队列单元模块:实现队列的抽象数据类型调用关系:四.详细设计1.相关头文件库的调用说明:include<>include<>define MAXSIZE 14define n 2define fee 102.元素类型、结点类型和结点指针类型:struct car{ char bb;int num;int time;};struct rangweicar{int num;int time;};typedef struct stackk{struct rangweicar HMAXSIZE;int topp;}SqStackk;define QNODE struct QnodeQNODE { int data;QNODE next;};3.栈类型和队列类型:typedef struct stack{struct car Gn;int top;}SqStack;typedef struct linkqueue{QNODE front,rear;int geshu;}LinkQueue;b=='E'||r.bb=='e'printf"STOP\n";else ifr.bb=='P'||r.bb=='p'printf"The number of parking cars is %d\n",s->top+1; else ifr.bb=='W'||r.bb=='w'printf"The number of waiting cars is %d\n",q->geshu; else ifr.bb=='A'||r.bb=='a'A_carss,q,r;else ifr.bb=='D'||r.bb=='d'D_carss,q,r;elseprintf"ERROR\n";}A_carsSqStack s,LinkQueue q,struct car a {QNODE t;ifs->top=n-1{s->top++;s->Gs->top.bb=;s->Gs->top.num=;s->Gs->top.time=;}else{printf"The parking place is full\n";t=QNODE mallocsizeofQNODE;t->data=;t->next=NULL;q->rear->next=t;q->rear=t;printf"the number of the car in the access road is:%d\n",q->rear->data;q->geshu++;}}int D_carsSqStack s,LinkQueue q,struct car d{int i,j,l;float x,y;QNODE p;SqStackk k;if==s->Gs->top.num{x=s->Gs->top.time;y=feex;printf"The time is %.2f hours,the fee is %.2f yuan\n",x,y;ifq->geshu==0{printf"The queue is empty\n";return 0;}else{p=q->front->next;q->front->next=p->next;s->Gs->top.num=p->data;s->Gs->top.time=;freep;q->geshu--;ifq->front->next==NULLq->rear=q->front;return 1;}}else{fori=0;i<s->top;i++{ifs->Gi.num= continue;else break;}ifi>=s->top{printf"ERROR\n";return -1;}x=s->Gi.time;y=feex;printf"The time is %.2f hours,the fee is %.2f yuan\n",x,y; k=SqStackk mallocsizeofSqStackk;k->topp=-1;forj=s->top;j>i;j--{k->topp++; k->Hk->topp.num=s->Gj.num;k->Hk->topp.time=s->Gj.time;s->top--;}forl=0;l<=k->topp;l++{printf"the informationnumber and time in the new stack is:\n"; printf"%d,%d\n",k->Hl.num,k->Hl.time;}s->top--;whilek->topp>=0{s->top++;s->Gs->top.bb='A';s->Gs->top.num=k->Hk->topp.num;s->Gs->top.time=k->Hk->topp.time;k->topp--;}ifq->geshu==0{printf"The access road is empty\n";return 2;}else{s->top++;p=q->front->next;q->front->next=p->next;s->Gs->top.num=p->data;s->Gs->top.time=;freep;q->geshu--;ifq->front->next==NULLq->rear=q->front;return 3;}}}4.主函数的伪码:main{SqStack s;LinkQueue q;QNODE p;struct car aaMAXSIZE;int i;s=SqStack mallocsizeofSqStack;s->top=-1;q=LinkQueue mallocsizeofLinkQueue;p=QNODE mallocsizeofQNODE;p->next=NULL;q->front=q->rear=p;q->geshu=0;printf"\n";printf" \n";printf" 停车场管理系统\n";printf" \n";printf"\n";fori=0;i<MAXSIZE;i++{printf"Please input the state,number and time of the car:\n";scanf"%c,%d,%d",&aai.bb,&aai.num,&aai.time;getchar;Judge_Outputs,q,&aai;ifaai.bb=='E'||aai.bb=='e' break;}}5.函数调用关系:五.测试分析:1.出现问题及解决办法:该程序是四个程序调试中最顺利的一个,只在一个地方上出了问题,就是输入字符时由于回车键也是字符,回车键总会被读入,导致经常输出“ERROR”;后来找到原因后在scanf函数后紧接着加了一个getchar;语句后就恢复了正常;2.方法优缺点分析:优点:用栈和队列来模拟停车场让整个问题显得简单,易于实现;缺点:栈和队列这两个数学模型用在停车场管理上还是有失妥当的,现实中停车场出口入口不可能为同一处,不可能当一辆车要离开,在它后面进来的车必须为它让路,因此无法用栈的“后进先出”原则来模拟;而且没有考虑便道上的车在等待过程中可以中途开走等情况,而这些都无法用队列的“先进先出”原则来模拟;3.主要算法的时间和空间复杂度分析:1由于算法Judge_Output函数根据判断条件,每次只选择一个程序段执行,所以其时间复杂度是O1;2由于算法A_cars函数根据判断条件,将数据入栈或入队列,所以其时间复杂度也是O1;3由于算法D_cars函数在出栈数据不在最顶端时需将n个数据先出该栈,再入新栈,再回旧栈的操作,故其时间复杂度是On;4所有算法的空间复杂度都是O1;六.使用说明程序运行后用户根据提示一次输入车辆的状态信息,车牌编号,时间,程序会根据车辆的状态信息调用相应的函数,并输出用户想得到的信息;七.调试结果输入数据:‘A’,1,5,‘A’,2,10,‘D’,1,15,‘A’,3, 20,‘A’,4,25,‘A’,5,30,‘D’,2,35,‘D’,4,40,‘P’,0,0,‘W’,0,0,‘F’,0,0,‘E’,0,0;输出数据:1号车停放时间为10小时,收费100元;2号车停放时间为25小时,收费250元;4号车停放5小时,收费50元;此时停车场有两辆车,便道上无车;若停车场已满,则会显示停车场已满的信息;若便道上无车等待停车,会显示便道上无车的信息;若中途有车离开,需其后的车让道,会显示进入临时停车场的车辆的信息;若输入‘F’,0,0,输出“ERROR”;若输入‘E’,0,0,程序结束;运行结果截屏:八.附录源程序文件清单:include<> /调用的头文件库声明/include<>define MAXSIZE 14define n 2define fee 10struct car /用该结构体来存放车的状态,编号和时间信息/ { char bb;int num;int time;};typedef struct stack /用该栈来模拟停车场/{struct car Gn;int top;}SqStack;struct rangweicar /用该结构体来存放临时让出的车辆的编号以及时间信息/ {int num;int time;};typedef struct stack /用该栈来模拟临时让出的车辆的停靠场地/ {struct rangweicar HMAXSIZE;int topp;}SqStackk;define QNODE struct QnodeQNODE { int data; /链队结点的类型/QNODE next;};typedef struct linkqueue /用该链队来模拟便道/{QNODE front,rear;int geshu;}LinkQueue;void Judge_OutputSqStack s,LinkQueue q,struct car r /该算法通过传递来的车辆信息调{ 用相关函数实现操作/ ifr.bb=='E'||r.bb=='e' /若车辆状态为‘E’,终止程序/printf"STOP\n";else ifr.bb=='P'||r.bb=='p' /若车辆状态为‘P’,输出停车场车辆数/ printf"The number of parking cars is %d\n",s->top+1;else ifr.bb=='W'||r.bb=='w' /若车辆状态为‘W’,输出便道车辆数/ printf"The number of waiting cars is %d\n",q->geshu;else ifr.bb=='A'||r.bb=='a' /若车辆状态为‘A’,调用A_cars函数/A_carss,q,r;else ifr.bb=='D'||r.bb=='d' /若车辆状态为‘D’,调用D_cars函数/D_carss,q,r;elseprintf"ERROR\n"; /若车辆状态为其他字母,报错/}A_carsSqStack s,LinkQueue q,struct car a /该算法实现对车辆状态为到达的车辆的操{QNODE t; 作/ifs->top=n-1 /若停车场还没有满,则车进停车场,并存入车辆的状态,车牌编{s->top++; 号和到达时间信息/s->Gs->top.bb=;s->Gs->top.num=;s->Gs->top.time=;}else{printf"The parking place is full\n"; /若停车场已满,车进便道,并显示该车的车牌编t=QNODE mallocsizeofQNODE; 号,同时记录便道车辆数目/t->data=;t->next=NULL;q->rear->next=t;q->rear=t;printf"the number of the car in the access road is:%d\n",q->rear->data;q->geshu++;}}int D_carsSqStack s,LinkQueue q,struct car d /该算法实现车辆状态为离开的车{int i,j,l; 辆的操作/float x,y;QNODE p;SqStackk k;if==s->Gs->top.num /若待离开车为最后进停车场的车的情况/{x=s->Gs->top.time;y=feex; /直接计算停车时间,费用并离去/printf"The time is %.2f hours,the fee is %.2f yuan\n",x,y;ifq->geshu==0 /若便道上无车,函数返回/{printf"The queue is empty\n";return 0;}Else /若便道上有车,第一辆车进停车场/{p=q->front->next;q->front->next=p->next;s->Gs->top.num=p->data; /并存入其车牌编号及进停车场的时间/s->Gs->top.time=;freep;q->geshu--;ifq->front->next==NULLq->rear=q->front; /若此时便道上无车,返回1/return 1;}}Else /待离开的车不是最后进停车场的那辆车的情况/ {fori=0;i<s->top;i++ /先找到待离开车在停车场中的位置/ {ifs->Gi.num= continue;else break;}ifi>=s->top{printf"ERROR\n";return -1;}x=s->Gi.time; /计算待离开车的停车时间并计算费用/y=feex;printf"The time is %.2f hours,the fee is %.2f yuan\n",x,y;k=SqStackk mallocsizeofSqStackk; /设立一个新栈临时停放为该车离开而让k->topp=-1; 路的车辆/forj=s->top;j>i;j--{k->topp++; k->Hk->topp.num=s->Gj.num;k->Hk->topp.time=s->Gj.time;s->top--;}forl=0;l<=k->topp;l++{printf"the informationnumber and time in the new stack is:\n";printf"%d,%d\n",k->Hl.num,k->Hl.time;} /显示在新栈中的车辆信息/ s->top--;whilek->topp>=0 /将新栈中的车重新开入停车场中/{s->top++;s->Gs->top.bb='A';s->Gs->top.num=k->Hk->topp.num;s->Gs->top.time=k->Hk->topp.time;k->topp--;}ifq->geshu==0 /若便道上无车,则返回2,无车开入停车场中/ {printf"The access road is empty\n";return 2;}Else /若便道上有车,则第一辆车开入停车场中/{s->top++;p=q->front->next;q->front->next=p->next;s->Gs->top.num=p->data;s->Gs->top.time=;freep;q->geshu--;ifq->front->next==NULLq->rear=q->front;return 3;}}}main{SqStack s;LinkQueue q;QNODE p;struct car aaMAXSIZE;int i;s=SqStack mallocsizeofSqStack; /对停车场初始化/s->top=-1;q=LinkQueue mallocsizeofLinkQueue;p=QNODE mallocsizeofQNODE; /对便道初始化/p->next=NULL;q->front=q->rear=p;q->geshu=0;printf"\n";printf" \n";printf" 停车场管理系统\n";printf" \n";printf"\n";fori=0;i<MAXSIZE;i++ /输入车辆信息/ {printf"Please input the state,number and time of the car:\n"; scanf"%c,%d,%d",&aai.bb,&aai.num,&aai.time; getchar;Judge_Outputs,q,&aai;ifaai.bb=='E' break;}}。
停车场管理主函数carpark.cpp
printf("车辆目前停在停车场%d位置。\n",park->top+1);
}
}
if(temp)
printf("车辆目前停在停车场%d位置。\n",park->top+1);
else
{
printf("停车场停车位已满,车辆转入便道等候。\n");
In_SeqQueue(road,c); //增加便道车辆
}
for(j=0;j<3;j++)
printf("%c",road->data[road->front].num[j]);
printf(" %d:%d\n",road->data[road->front].time.Htime,road->data[road->front].time.Stime);
printf("车牌为");
for(i=0;i<3;i++)
printf("%c",park->data[park->top].num[i]);
printf("进入停车场。\n");
printf("请输入车辆进入时间(**:**):");
scanf("%d",&in);
c语言停车场管理系统
cteam* initTeam(){
cteam *Q;
Q=(cteam *)malloc(sizeof(teamNode));
Q->front=(teamPtr)malloc(sizeof(teamNode));
Q->front->next=NULL;
// 仅供参考
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define N 50 //停车场最多停车数
typedef struct{
char cnum[8];
float date;
}pnode; //栈中结点数据类型
printf(" >>\n");
printf(" 3.退出系统\n\n\n");
printf("***>>>>>>>>>>>>>>>>>>>> Made by Lemon'x <<<<<<<<<<<<<<<<<<<<<***\n\n");
Q->front->number=50;
Q->rear=Q->front;
return Q;
} //初始化队列
int inTeam(cteam *Q,char cnum[]){ //接收队列的地址,来车的车牌号码
停车场管理系统源代码
〃停车场管理系统# include<stdio.h>#include<stdlib.h>#define OVERFLOW 0#define ERROR 0#define OK 1#define STACKSIZE 2 〃车库容量〃时间节点typedef struct time{int hour;int min;}Time;〃车辆信息typedef struct{char CarNum;float time;int pos_a; 〃车在停车场中的位置int pos_b; 〃车在便道上的位置int flag;}Car z Car2;〃车库信息(顺序栈)typedef struct{Car *top;Car *base;int stacksize;}SqStack;〃初始化int lnitStack(SqStack &S){S.base=new Car[STACKSIZE];if('S.base) exit(OVERFLOW);S.top=S.base;S.stacksize=STACKSIZE;return OK;}〃判空int StackEmpty(SqStack S){if(S.top==S.base) return OK;else return ERROR;〃判满int StackFull(SqStack S){if(S.top-S.base>=S.stacksize) return OK; else return ERROR; }〃入栈int Push(SqStack &S,Car e){if(S.top-S.base==S.stacksize) return ERROR; *S.top++=e;return OK;}〃出栈int Pop(SqStack &S,Car &e){if(S.top==S.base) return ERROR; e=*-S.top;return OK;}〃遍历栈int StackTraverse(SqStack S) {Car *p=S.top;Car *q=S.base;int 1=1;if(StackEmpty(S)){for(int j=l;j<=STACKSIZE;j++){ printf("\t 车牌:"); printf("\t\t 到达时间:”); printf("\t 位置%d:空空",j); printfCV);}return OK;}while(p!=q){Car car=*(q);printf(H\t 车牌:%d,,/car.CarNum); printf("\t\t 到达时间:%5.2f"/car.time); printf("\t\t 位置:%d,,J++);printf("\n M);q++;}return OK;}〃备用车道(顺序栈)typedef struct {Car2 *top2;Car2 *base2; // int stacksize2;}SqStack2;〃初始化int lnitStack2(SqStack2 &S2){S2.base2=new Car2[STACKSIZE]; if(!S2.top2)exit(OVERFLOW); //S2.top2=S2.base2;S2.stacksize2=STACKSIZE;return OK;}〃判空int StackEmpty2(SqStack2 S2){ if(S2.top2==S2.base2) return OK; else return ERROR;}〃进栈int Push2(SqStack2 &S2,Car2 e2){ if(S2.top2-S2.base2==STACKSIZE) return ERROR; *S2.top2++=e2;return OK;}〃出栈int Pop2(SqStack2 &S2/Car2 &e2){ if(S2.top2==S2.base2) return ERROR; e2=*-S2.top2;return OK;}〃车道信息(链队)typedef struct QNode{Car data;struct QNode *next;}QNode,*QueuePtr;typedef struct{QueuePtr front;QueuePtr rear;}Lin kQueue;〃初始化int lnitQueue(LinkQueue &Q){ Q.front=Q.rear二new QNode; Q.front->next=NU LL;return OK;}〃进队int EnQueuefLinkQueue &Q,Car e){ QueuePtr p;p 二new QNode;p->data=e; p->next=NULL;Q.rear- >n ext=p;Q.rear=p; return OK;}〃判空int QueueEmpty(LinkQueue Q){ if(Q.front==Q.rear) return OK; else return ERROR; }〃出队int DeQueue(LinkQueue &QCar &e){ QueuePtr p;if(Q.front==Q.rear) return ERROR; p=Q.fr ont・>n ext;e=p->data;Q.front- >n ext=p->n ext;delete p;return OK;}〃主函数int main(){int i=l;int j=l;int status;float time,money;LinkQueue Q;Car car_l,car_Dcar_M;SqStack S;SqStack2 S2;InitStack(S);lnitStack2(S2);InitQueue(Q);while(l){printf("\t\t\t 欢迎来到XXX 停车场! \n M);printf("************ ***************************************************** printf(H\t\t\tl-车辆到达停车场\rf); printf("\t\t\t2-车辆离开停车场\n“);printf(”\t\t\t3-停车场存放车辆情况\n“); printf(n\t\t\tO-退出程序\nj;printf("************ ***************************************************** printf(H选择(0-3):\n H); scanf(,,%d,,/&status);if(status==l){printf("\t请输入车牌号:");scanf(,,%d"/&car_I.CarNum);printf("\t请输入车到达的时间:");scanf(,,%f,,,&car_l .time);if(!StackFull ⑸){Push(S,car_l); 〃车进入车库carj.pos_a=i;car_l.flag=l;i=i+l;for(int m=l;m<50;m++) 〃边线printfC'-");printf(H\n H);printfC'\t 车牌号:“);printf( "%d",car_I.CarNum);printf("\t 到达时间:");printf( "%5.1f\t"f car_l.time);printf("\t 车库中的位置是:%d\n"z car_l.pos_a);for(int m=l;m<50;m++) 〃边线printfCV);printf(“\n“);printf(“\n“);}else{EnQueue(Q,car_l);car_l.pos_b=j;car_l.flag=O; //++j;printfCV);printf(”\tSorry!我们的车库已满!!!,您可以把车!!免费!!停在车道上!\n”);printfCV);for(int m=l;m<50;m++) 〃边线printfC'..");printfCV);printf("\t 车牌号:“);printf( "%d",car_I.CarNum);printf("\t 便道上的位置为:%d\n"z car_l.pos_b);for(int m=l;m<50;m++) 〃边线printfC'..");printfCV);printf(“\n“);printf(“\n“);}}else if(status==2){ 〃指令为2,开车离去(如果车在车库里收取停车费;在便道上则免费)printfC请输入客户的车牌号:”);scanf("%d",&car_D.CarNum);printf("iW输入现在的时间:”);scanf("%f\&car_D.time);i=i-l;int flag=O;〃判断车是否在便道上if(StackFull ⑸){Car *p=S.top;Car *q=S.base;while(p!=q){Car car=*(q);if(car.CarNum!=car_D.CarNum){flag++;}if(car.CarNum==car_D.CarNum){goto loop;}q++;} //whileif(flag>=STACKSIZE){printf("您的车停在便道上,所以免费!!!");}printfCV);printfCV);printfCV);} //ifelse{loop:do{ 〃挡在前面的车给要出去的车让路Pop(S,car_M);〃加一个判断,判断是不是停车场里的车if(car_D.CarNum!=car_M.CarNum){Push2(S2,car_M);}else{carJ.time=car_M.time;}}while(car_D.CarNum!=car_M.CarNum);while(!StackEmpty2(S2)){ 〃让路的车返回去Pop2(S2,car_M);Push(S,car_M);}while(!QueueEmpty(Q)&&!StackFull ⑸){if(!StackFull (S)){DeQueue(Q,car_M); 〃便道上的车离开后进入停车场,那么后面的车的位置都得变。
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 为新的栈顶元素。
停车场管理系统代码
for(i=0;i<chewei_num;i++)
{
pos[i]=-1;
}
for(i=0;i<biandao_num+car_range;i++)
{
wait[i]=-1;
}
cout<<"第0小时"<<endl;
out<<"第0小时"<<endl;
int pos;
int wait;
int arrive_time;
int leave_time;
int park_time;
int fee;
}cars[24*Range];
int pos[2000];
int wait[2000];
int sum_time=0;
int sum_fee=0;
int sum_arrive=0;
int sum_leave=0;
int sum_away=0;
int pos_num=0;
int wait_num=0;
int come_num;
int l_num;
int front=0;
int now_time;
int num;
int chewei_num=M;
out<<"车号:"<<car<<" 到达时间:"<<cars[car].arrive_time<<" 离开时间:"<<cars[car].leave_time<<" 车位:"<<cars[car].pos<<" 停留时间:"<<cars[car].park_time<<" 费用:"<<cars[car].fee<<endl;
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}
Status w_total(SqQueue Q)
{
return QueueLength(Q);
};/*在便车道的车辆总数*/
Status EnQueue(SqQueue &Q,int e)
{
if((Q.rear+1)%MAXQSIZE==Q.front)
typedef struct LNode
{
struct
{
int stnumber;
char num[10];
struct now_time reach;
struct now_time leave;
float fee;
int totalhour;
}data;
struct LNode *next;
}LNode,*LinkList;
停车场管理系统
某停车场可以停放n辆汽车,该停车场只有一个大门,每辆汽车离开停车场都要求之前的汽车必须先退出停车场为它让道,而后让道的汽车再次驶入停车场,停车场示意图如下:
要求设计停车管理系统,实现车辆的进入、离开并根据停车时间计费。
程序:
#include <stdio.h>
#include <stdlib.h>
printf( "离开时间%d:%d:%d\n", newtime->tm_mday,newtime->tm_hour,newtime->tm_min);
printf( "您的停车费用总共:%f",fee);
printf("\n\n------------------------------\n\t*******谢谢您的光临,祝您一路平安********!\n\n");
{
int j=0,m=0,k;
int a=0;
for(int i=0;num[i]!='\0';i++)
{
j++;
}
for(i=1;i<=MAX;i++)
{
if(strcmp(set[i].num,num)==0)
{
m=1;
break;
}
}
if(j!=3||m==1)
return 1;
else
return 0;
{
p=p->next;
++j;
}
if(!p||j>i-1)
return ERROR;
s=(LinkList)malloc(sizeof(LNode));
s->data.fee=fee;
s->data.totalhour=totalhour;
s->data.stnumber=lset;
s->data.leave.mday=day;
Status Push(SqStack &S,int e)
{
if(S.top-S.base>=S.stacksize)
{
if(!S.base)
exit(OVERFLOW);
S.top=S.base+S.stacksize;
}
*S.top++=e;
return OK;
}
void enterstop( LinkList clist,SqStack &S,char number[10],int *come)
#include<string.h>
#include <time.h>
#define OK 1
#define NULL 0
#define ERROR 0
#define TURE 1
#define FALSE 0
#define OVERFLOW -2
typedef int Status;
#define MAXQSIZE 100
{
int e;
*come=*come+1;
Pop(S,e);
set[e].setnumber=e;
copy(set[e].num,number);
struct tm *newtime;
char am_pm[] = "AM";
time_t long_time;
time( &long_time ); /* Get time as long integer. */
int lset,t;
int j=1;
int totalhour;
float fee;
printf ("请输入您的车位号");
do{
scanf ("%d",&lset);
getchar();
for(int i=0;i<=MAX;i++)
{
if(set[lset].num[1]=='#')
j=0;
}
if(j==0)
printf("\n\n****请核对您的停车信息****\n");
printf("车牌号:%s\n",set[e].num);
printf("停车车位号:%d\n",set[e].setnumber);
printf( "到达时间%d:%d:%d\n", set[e].reach.mday,set[e].reach.hour,set[e].reach.min);
newtime = localtime( &long_time ); /* Convert to local time. */
set[e].reach.hour=newtime->tm_hour;
set[e].reach.mday=newtime->tm_mday;
set[e].reach.min=newtime->tm_min;
{
printf("*****车场并没有停车*******\n");
return ERROR;
}
else
{
if(lset>MAX ||lset<1)
{
printf("*****您输入有误,该车号并不存在!*******\n请重新输入您的车位号:\n");
t=1;
}
else
{
if(set[lset].num[1]=='#')
{
Q.base=(char*)malloc(100*sizeof(char[10]));
if(!Q.base)exit(OVERFLOW);
Q.front=Q.rear=0;
return OK;
}
/*模拟通道*/
Status stack_empty(SqStack S)
{
if(S.top==S.base)
fee=price*totalhour;
printf("****以下是您本次停车的信息****\n");
printf("车牌号:%s\n",set[lset].num);
printf("停车车位号:%d\n",set[lset].setnumber);
printf( "到达时间%d:%d:%d\n", set[lset].reach.mday,set[lset].reach.hour,set[lset].reach.min);
}
Status lListInsert_Link(LinkList &llist,int i,int lset,int totalhour,float fee,int day,int hour,int min)
{
LNode *p,*s;
int j;
p=llist;
j=0;
while(p&&j<i-1)
{
LNode *p,*s;
int j;
p=L;
j=0;
while(p&&j<i-1)
{
p=p->next;
++j;
}
if(!p||j>i-1)
return ERROR;
s=(LinkList)malloc(sizeof(LNode));
s->data.stnumber=set[setnumber].setnumber;
return ERROR;
Q.base[Q.rear]=e;
Q.rear=(Q.rear+1)%MAXQSIZE;
return OK;
}
Status enterlane(SqQueue &Q,int waitenumber)
{
EnQueue(Q,waitenumber);
return OK;
}/*进入便车道等待*/
s->next=p->next;
p->next=s;
return OK;
}
void ccord(LinkList clist,int i,int setnumber)
{
ListInsert_Link(clist,i,setnumber);
}
Status initStack(SqStack &S)
{
int i;
s->data.reach.hour=set[setnumber].reach.hour;