本文目录一览：
数据结构的栈和队列及其应用，设计一个停车场管理系统
//停车场管理
#include "stdio.h"
#include"stdlib.h"
#include"string.h"
#define OK 1
#define ERROR 0
#define MAX_BUF 20//倒车辅组栈长度
#define MAX_NUM 6//停车场栈长度
#define RATE 5//停车场费率
#define MAXLEN 255//串的最大长度
#define MAX_TEST 100//测试车辆的最大数目
//typedef char SString[MAXLEN];
typedef struct
{//汽车状态，'A'为到达，'D'为离开，'E'为输入结束
char status; //汽车状态
int symbol;//车牌号码
int t;//到达或离去的时间
}DCar;
typedef struct
{//顺序栈
DCar *base,*top;
int stacksize;
}SqStack;
typedef struct QNode
{//队列结点
DCar data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{//链队列
QueuePtr front,rear;
}LinkQueue;
void InitStack(SqStack S,int size)
{ //构造一个空停车场栈
S.top=S.base=(DCar*)malloc(size*sizeof(DCar));
S.stacksize=size;
}
int Push(SqStack S,DCar e)
{//栈不满则入栈,否则返回错误
if(S.top-S.baseS.stacksize)
{
*S.top++=e;
return OK;
}
return ERROR;
}
int Pop(SqStack S,DCar e)
{//栈非空则执行出栈操作,否则返回错误
if(S.top!=S.base)
{
e=*--S.top;return OK;
}
return ERROR;
}
void InitQueue(LinkQueue Q)
{//构造一个带头结点的空队列(便道)
Q.front=(QueuePtr)malloc(sizeof(QNode));
Q.front-next=NULL;
Q.rear =Q.front ;
}
int EnQueue(LinkQueue Q,DCar e)
{//入队
QueuePtr p;
p=(QueuePtr)malloc(sizeof(QNode));
if(!p)return ERROR;
p-data=e;p-next=NULL;
Q.rear-next =p;Q.rear=p;
return OK;
}
int DeQueue(LinkQueue Q,DCar e)
{//出队
QueuePtr p=Q.front-next ;//p指向队头元素
if(!p)return ERROR;//空队则返回错误
e=p-data;
Q.front-next=p-next;
if(Q.rear==p)Q.rear=Q.front;
free(p);return OK;
}
void DestroyQueue(LinkQueue Q){ //销毁队列
while(Q.front){
Q.rear=Q.front-next;
free(Q.front);
Q.front=Q.rear=NULL;
}
}
char Search(SqStack S,LinkQueue Q,int lisence)
{//根据车牌号查找要离开的车是在停车场(栈)还是在便道上(队列)
DCar *p=S.base;//设置栈中的搜索指针
QueuePtr q=Q.front-next;//链队列中的搜索指针
while(pS.top){//在栈中搜索
if(p-symbol==lisence)
return 'S';//要离开的车在停车场(栈)
p++;
}
while(q){//在队列中搜索
if(q-data.symbol==lisence)
return 'Q';//要离开的车在便道上(队列)
q=q-next;
}
return 'N';//对应车牌的车没有，输入有误
}
int Charge(float stay)
{//根据停留的时间stay计算费用
//每小时RATE元，超过1小时不足2小时按2小时算，依次内推
return ((int)stay+1)*RATE;
}
int Arrive(SqStack S,LinkQueue Q,DCar c)
{//汽车到达处理函数
if(Push(S,c))//进入停车场成功
{
printf("\n时间%d：%d号车进入停车场\n",c.t,c.symbol);
return OK;
}
if(EnQueue(Q,c))return OK;//进入便道成功
return ERROR;
//printf("\nche%d\n",S.top-S.base);
}
void Depart(SqStack S,LinkQueue Q,DCar c)
{//汽车c离开处理函数
char locate;
locate=Search(S,Q,c.symbol);//确定要离开车的位置
SqStack Sbuf;//规避所栈
QueuePtr p;
DCar e;
int stay;
InitStack(Sbuf,MAX_BUF);
switch(locate)
{
case 'S'://汽车c在停车场(栈内)
while((S.top-1)-symbol!=c.symbol)
{//在汽车c后面进入的车依次倒车
Pop(S,e);//退出停车场
Push(Sbuf,e);//进入规避所
}
Pop(S,e);//汽车c离开
stay=c.t-e.t;//计算停留时间
printf("\n%d号车离开,停留时间%d,费用：%d",c.symbol,stay,stay*RATE);
printf("\n");
while(Sbuf.base!=Sbuf.top)
{//按原来次序再进入停车场
Pop(Sbuf,e);Push(S,e);
}
if(Q.front!=Q.rear)
{//如果便道上有车(队列非空)则第一辆车进入停车场
DeQueue(Q,e);
e.t=c.t;//开始计时收费
Push(S,e);
printf("\n%d号车进入停车场,时间：%c\n",e.t,e.symbol);
}
break;
case 'Q'://汽车c在便道上(队列中)
p=Q.front-next;//指向队头结点
while(p-data.symbol==c.symbol)
{//将汽车c前面的车开进规避所
DeQueue(Q,e);Push(Sbuf,e);//进入规避所
p=Q.front-next;
}
DeQueue(Q,e);//汽车c离开
printf("\n%d号车未进停车场离开，不收费！",e.symbol);
printf("\n");
while(Sbuf.top!=Sbuf.base)
{//进入规避所的车按原来次序返回到便道上(队列)
Pop(Sbuf,e);
p=(QueuePtr)malloc(sizeof(QNode));
p-data=e;
p-next=Q.front-next;//插入到队头，注意：不是入队操作
Q.front-next=p;
}
break;
case 'N':printf("\n%d车辆信息错误！\n",c.symbol);break;
}
free(Sbuf.base );
}
int main(){
DCar car[MAX_TEST]={{'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}};
SqStack S;
LinkQueue Q;
InitStack(S,MAX_NUM);
InitQueue(Q);
for(int i=0;car[i].status!='E';i++)
{
if(car[i].status=='A')Arrive(S,Q,car[i]);
else Depart(S,Q,car[i]);
}
DestroyQueue(Q);
free(S.base);//销毁栈
return 0;
}
停车场管理 数据结构
真巧，我们刚做完这个题目！发给你看看：一定要采纳哦！嘿嘿
#include conio.h
#include malloc.h
#include stdio.h
#include stdlib.h
#include windows.h
// 清空当前屏幕
#define ClearScreen() system( "cls" )
// 显示字符串 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, 将其容量设置为 nSize
void InitStack( LPTCARSTACK lpCarStack, int nSize )
{
lpCarStack = ( LPTCARSTACK ) malloc( sizeof ( TCARSTACK ) );
lpCarStack-lpCarInformation = ( LPTCARINFORMATION ) malloc(
nSize * sizeof ( TCARINFORMATION )
);
lpCarStack-nTop = -1;
lpCarStack-nStackSize = nSize;
}
// 车辆信息 carinfo 入栈 lpCarStack
void Push( LPTCARSTACK lpCarStack, TCARINFORMATION carinfo )
{
lpCarStack-nTop++;
lpCarStack-lpCarInformation[lpCarStack-nTop] = carinfo;
}
// 车辆信息从栈 lpCarStack 中弹出并存入 carinfo
void Pop( LPTCARSTACK lpCarStack, TCARINFORMATION carinfo )
{
carinfo = lpCarStack-lpCarInformation[lpCarStack-nTop];
lpCarStack-nTop--;
}
// 若栈 lpCarstack 空,返回 TRUE;否则,返回 FALSE
BOOL IsStackEmpty( LPTCARSTACK lpCarStack )
{
return lpCarStack-nTop == -1;
}
// 若栈 lpStackFull 满,返回 TRUE;否则,返回 FALSE
BOOL IsStackFull( LPTCARSTACK lpCarStack )
{
return lpCarStack-nTop == ( lpCarStack-nStackSize - 1 );
}
// 销毁栈 lpCarStack,将指针 lpCarStack 置为 NULL
void 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;
// 初始化链队 lpCarQueue
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;
}
// 车辆信息 carinfo 入队 lpCarQueue
void 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 中出队并存入 carinfo
void DeQueue( LPTCARQUEUE lpCarQueue, TCARINFORMATION carinfo )
{
LPTCARNODE lpTemp = lpCarQueue-lpHead-lpNext;
carinfo = lpTemp-carinfo;
lpCarQueue-lpHead-lpNext = lpTemp-lpNext;
free( lpTemp );
lpCarQueue-nEffectiveSize--;
}
// 若链队 lpCarQueue 为空,返回 TRUE;否则,返回 FALSE
BOOL IsQueueEmpty( LPTCARQUEUE lpCarQueue )
{
return lpCarQueue-nEffectiveSize == 0;
}
// 销毁链队 lpCarQueue
void 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 )
{
int nParkCapability = 0; // 停车场容量
putchar( '\n' );
printf("\t\t===========欢迎你进入停车场管理系统===========\n");
printf("\t\t 徐沙利 20074470149\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();
putchar( '\n' );
puts( "--------------------" );
puts( "[命令类型]" );
puts( "A - 车辆到达" );
puts( "D - 车辆离开" );
puts( "E - 停止输入" );
puts( "O - 显示当前停车场和便道使用情况" );
putchar( '\n' );
puts( "例:" );
puts( "A,冀A1234,14:26" );
puts( "D,冀A1234,16:51" );
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( "徐沙利 - Build201006\n" );
puts( "********************" );
break;
}
else if ( cCommandType == 'O' )
{
ClearScreen();
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++停车场管理系统用哪种数据结构编写?为什么?
说一下自己的个人看法：
就用最简单的数组吧
停车场管理系统主要是针对停车位来进行操作控制
而每个车位之间又没有什么联系
一辆车进了停车场
看到空位就停上去
把车位封装成一个结构体
它包括{
车位编号；
该车位上所停车的车牌号；（如果没有，就使它为空值）
入场时间；（车进来时记录）
出场时间；（车离开时记录）
所需费用；（按你的收费标准收费，按小时或其它标准）
}
车进来时
入口处给它分配一个空着的车位号
同时记录入场时间
车离开时
出口处记录它出场时间
同时计算出费用
提醒司机缴费
发布于 2022-09-03 12:24:11 回复
发布于 2022-09-03 15:18:20 回复