#include<stdio.h>
#include<malloc.h>
#include<string.h>
#define TRUE 1
#define FALSE 0
#define Stack_Size 2
//车辆信息
typedef struct Car
{
char Number[20];//车牌号
int time;//到达时刻
}Car;
//车库栈定义
typedef struct
{
Car elem[Stack_Size];
int top;
}SeqStack;
//暂退出车栈道定义
typedef struct
{
Car elem2[Stack_Size];
int top2;
}SeqStack2;
//队列定义
typedef struct Node
{
Car data;//数据域
struct Node *next;//指针域
}LinkQueueNode;
typedef struct
{
LinkQueueNode *front;
LinkQueueNode *rear;
int length;
}LinkQueue;
//以下是函数原型说明
void InitStack(SeqStack *s);
int IsEmpty(SeqStack *s);
int Push(SeqStack *s,Car e);
int Pop(SeqStack *s,Car *e);
int InitQueue(LinkQueue *Q);
int EmptyQueue(LinkQueue Q);
int EnterQueue(LinkQueue *Q,Car x);
int DeleteQueue(LinkQueue*Q,Car *x);
int CarArrive(SeqStack *s,LinkQueue *Q,char num[],int arrivetime);
int CarLeave(SeqStack *s,LinkQueue *Q,SeqStack *s2,char[],int leavetime);
//以下是函数定义
void InitStack(SeqStack *s)//顺序栈的初始化函数
{
s->top=-1;
}
int IsEmpty(SeqStack *s)//顺序栈的判栈空函数
{
if(s->top==-1)
return(TRUE);
else
return(FALSE);
}
int IsFull(SeqStack *s)
{
if(s->top==Stack_Size)
return(TRUE);
else
return(FALSE);
}
int Push(SeqStack *s,Car *e)//顺序栈的进栈函数
{
if(s->top==Stack_Size-1)
return(FALSE);
else
{
s->top++;
s->elem[s->top]=*e;
return(TRUE);
}
}
int Pop(SeqStack *s,Car *e)//顺序栈的出栈函数
{
if(s->top==-1)
return(FALSE);
else
{
*e=s->elem[s->top];
s->top–;
return(TRUE);
}
}
int InitQueue(LinkQueue *Q)//链队列的初始化
{
Q->length=0;
Q->front=(LinkQueueNode*)malloc(sizeof(LinkQueueNode));
if(Q->front!=NULL)
{
Q->rear=Q->front;
Q->front->next=NULL;
return(TRUE);
}
else
return(FALSE);//溢出
}
int EmptyQueue(LinkQueue *Q)//链队列的判空
{
if(Q->front==Q->rear)
return(TRUE);
else
return(FALSE);
}
int EnterQueue(LinkQueue *Q,Car *x)//链队列的入队操作，将数据元素x插到队列中
{
LinkQueueNode *NewNode;
NewNode=(LinkQueueNode*)malloc(sizeof(LinkQueueNode));
if(NewNode!=NULL)
{
NewNode->data=*x;
NewNode->next=NULL;
Q->rear->next=NewNode;
Q->rear=Q->rear->next;
Q->rear->next=NULL;
Q->length++;
return(TRUE);
}
else
return(FALSE);//溢出
}
int DeleteQueue(LinkQueue *Q,Car *x) //链队列的出队操作，对头出列，并存放到x所指的储存空间中
{
LinkQueueNode *p;
if(Q->front==Q->rear)
return(FALSE);
p=Q->front->next;
Q->front->next=p->next; //对头元素p出列
if(Q->rear==p) //如果对中只有一个元素p，则p出对后成为空队
Q->rear=Q->front;
*x=p->data;
free(p); //释放存储空间
Q->length–;
return(TRUE);
}
/***********************************车辆到达函数*************************************/
int CarArrive(SeqStack *s,LinkQueue *Q,char num[],int arrivetime)
{ Car *come;
come=(Car*)malloc(sizeof(Car));
strcpy(come->Number,num);//到达车辆的车牌号
come->time =arrivetime;//到达车辆的时间
if(s->top<Stack_Size-1) //若车库未满，直接入车库
{
Push(s,come);//车辆入栈
printf(“————————————-\n”);
printf(“车辆%s停在车库%d号位上\n”,num,s->top+1);
}
else
{
EnterQueue(Q,come);//若车库已满，就入队列
printf(“————————————-\n”);
printf(“车辆%s停在便道%d号位上\n”,num,Q->length);
}
return 0;
}
/**********************************车辆离开函数****************************************/
void Carleave(SeqStack *s,LinkQueue * Q,char num[],int leavetime)
{
SeqStack s2;
InitStack(&s2 );
Car *Acar;//要离开车辆
Acar=(Car*)malloc(sizeof(Car));
int money,parktime;
while(!IsEmpty(s)&&(strcmp(s->elem[s->top].Number,num)))
//当”车库”栈不空，并且栈顶车辆不是要离开的车时，重复下面操作：
{ // 将”车库”栈的栈顶车辆退出；
Pop(s, Acar);
//让退出的车辆进入”暂时退车道”栈；
Push(&s2,Acar);
}
//如果找到要离开的车辆，则计算并输出停车费用；
Pop(s, Acar);
parktime=leavetime-Acar->time;
money=5*parktime;//此处可根据实际情况变动
printf(“————————————-\n”);
printf(“%s的停车时间为%d小时，停车费用为%d元\n”,num,parktime,money);
//将”暂时退车道”栈中的车辆倒回”车库”栈；
while(!IsEmpty(&s2))
{
Pop(&s2,Acar);
Push(s, Acar);
}
// 如果”便道”队列不空，则队头车辆出队，并进入”车库”栈；
if(!EmptyQueue(Q))
{
Car *Bcar;//出便道进车库的车
Bcar=(Car*)malloc(sizeof(Car));
DeleteQueue(Q,Bcar);
Bcar->time=leavetime;//将”出队车辆”的到达时刻改为”离开车辆”的离开时刻。
Push(s,Bcar);
printf(“便道上的%s进入车库，入库时刻为%d，当前停放在车库%d号位\n”,Bcar->Number,Bcar->time,s->top+1);
}
}
/************************************车库停车情况一览表函数***************************************/
void printfstack(SeqStack s)
{
Car *Ccar;
Ccar=(Car*)malloc(sizeof(Car));
if(s.top ==-1)
printf(“车库无车\n”);
else
{
while(s.top !=-1)
{
*Ccar=s.elem [s.top];
s.top–;
printf(“%s %d\n”,Ccar->Number,Ccar->time);
}
}
}
/********************************便道停车情况一览表函数***************************************/
int printfQueen(LinkQueue Q)
{ Car *Dcar;
Dcar=(Car*)malloc(sizeof(Car));
LinkQueueNode *p;
p=Q.front->next;
if(Q.front==Q.rear)
{ printf(“便道无车\n”);
return(FALSE);
}
while(Q.front!=Q.rear)
{
*Dcar=p->data;
if(Q.rear==p) //如果对中只有一个元素p,则p出对后成为空队
Q.rear=Q.front;
printf(“%s %d\n”,Dcar->Number,Dcar->time);
p=p->next;
}
return(TRUE);
}
/************************************主函数*******************************************/
int main(void)
{ char ch;
SeqStack my_stack ;
LinkQueue my_queue;
InitStack(&my_stack );
InitQueue(&my_queue );
while(1)
{
char t[10];
printf(“*************************************\n”);
printf(” WELCOME TO THE SMART PARKING LOT \n”);
printf(“*************************************\n”);
printf(” 请输入车辆信息: \n”);
printf(” A表示车辆到达 \n”);
printf(” D表示车辆离开 \n”);
printf(” E表示输入结束 \n”);
printf(“————————————\n”);
scanf(“%s”,&t);
ch=getchar();
int now;
char c[10];
printf(“———————–\n”);
printf(“请输入车牌和当前时刻\n”);
printf(“———————–\n”);
scanf(“%s”,c);
scanf(“%d”,&now);
if(t[0]==’A’)
{
CarArrive(&my_stack,&my_queue, c,now);
LinkQueueNode *tmp = my_queue.front;
printf(“\n”);
}
else if(t[0]==’D’)
{
Carleave(&my_stack,&my_queue,c,now);
printf(“\n”);
}
else if(t[0]==’E’)
{
printf(“—————————–\n”);
printf(“当前车库中还有%d辆车，便道上有%d辆车，再见!\n”,my_stack.top+1,my_queue.length);
break;
}
printf(“+++++++++++++++++++\n”);
printf(“车库停车情况一览表：\n”);
printfstack(my_stack);
printf(“便道停车情况一览表：\n”);
printfQueen(my_queue);
printf(“+++++++++++++++++++\n”);
}
}
