#include<stdio.h>
#include<malloc.h>
#define PACKSIZE 2
#define ROADSIZE 2
#define PRICE 0.55
#include<stdlib.h>
typedef struct time
{
int hour;
int min;
}time;/*时间结点*/
typedef struct Car
{ char num[10];
time reach;
time leave;

}Car;/*汽车信息*/
typedef struct Cpark
{
Car *stack[PACKSIZE+1];
int top;
}Cpark;/*模拟车站，即停车场*/
typedef struct car
{
Car *data;
struct car *next;
}car;
typedef struct Road
{
car *head;
car *rear;
}Road;/*便道*/

/*********************************************/
/*********************************************/
void InitStack(Cpark *);/*初始化停车场*/
int InitQueue(Road *);/*初始化便道*/
int Arrival(Cpark *,Road *);/* 车辆到达*/
void Leave(Cpark *,Cpark *,Road *);/*车辆离开*/
void List(Cpark,Road);/*显示车辆的信息*/
/*********************************************/
/*********************************************/

void main()
{
Cpark Enter,Temp;
Road Wait;
int ch;
InitStack(&Enter);/*初始化停车场*/
InitStack(&Temp); /*初始化让路的临时栈*/
InitQueue(&Wait);/*初始化便道*/
while(1)
{
printf("\n1. the car arrive");
printf(" 2. the car leave");
printf(" 3. show message ");
printf(" 4. exit\n");
while(1)
{
scanf("%d",&ch);
if(ch>=1&&ch<=4)break;
else printf("\nplease choose：1|2|3|4.");
}
switch(ch)
{
case 1:Arrival(&Enter,&Wait);break; /*车辆到达*/
case 2:Leave(&Enter,&Temp,&Wait);break; /*车辆离开*/
case 3:List(Enter,Wait);break; /*列表打印信息*/
case 4:exit(0); /*退出主程序*/
default: break;
}
}
}
void InitStack(Cpark *s)/*初始化栈*/
{
int i;
s->top=0;
for(i=0;i<=PACKSIZE;i++)
s->stack[s->top]=NULL;
}
int InitQueue(Road *Q)/*初始化便道*/
{
Q->head=(car *)malloc(sizeof(car));
if(Q->head!=NULL)
{
Q->head->next=NULL;
Q->rear=Q->head;
return(1);
}
else
return(-1);
}
void PRINT(Car *p,int room)/*打印出站车的信息*/
{
int A1,A2,B1,B2;
printf("\nplease input the leaving time:/**:**/");
scanf("%d,%d",&(p->leave.hour),&(p->leave.min));
printf("\nthe number of the car:");
puts(p->num);
printf("\nthe time of the car arrive: %d,%d",p->reach.hour,p->reach.min);
printf("the leaving time: %d:%d",p->leave.hour,p->leave.min);
A1=p->reach.hour;
A2=p->reach.min;
B1=p->leave.hour;
B2=p->leave.min;
printf("\nThe fares : %2.1f",((B1-A1)*60+(B2-A2))*PRICE);
free(p);
}

int Arrival(Cpark *Enter,Road *W) /*车辆到达*/
{
Car *p;
car *t;
p=(Car *)malloc(sizeof(Car));
flushall();
printf("\ninput the number of the car(for examle:A1234):");
gets(p->num);
if(Enter->top<PACKSIZE) /*车场未满，车进车场*/
{
Enter->top++;

printf("\nthe time thecar arrive:/**:**/");
scanf("%d:%d",&(p->reach.hour),&(p->reach.min));
Enter->stack[Enter->top]=p;
return(1);
}
else /*车场已满，车进便道*/
{
printf("\nThe car should wait on the Road");
t=(car *)malloc(sizeof(car));
t->data=p;
t->next=NULL;
W->rear->next=t;
W->rear=t;
return(1);
}
}
void Leave(Cpark *Enter,Cpark *Temp,Road *W)
{ /*车辆离开*/
int i, room;
Car *p,*t;
car *q;
/*判断车场内是否有车*/
if(Enter->top>0) /*有车*/
{
while(1) /*输入离开车辆的信息*/
{
printf("\nPlease input the position in the Cpark/1--%d:",Enter->top);
scanf("%d",&room);
if(room>=1&&room<=Enter->top) break;
}
while(Enter->top>room) /*车辆离开*/
{
Temp->top++;
Temp->stack[Temp->top]=Enter->stack[Enter->top];
Enter->stack[Enter->top]=NULL;
Enter->top--;
}
p=Enter->stack[Enter->top];
Enter->stack[Enter->top]=NULL;
Enter->top--;
while(Temp->top>=1)
{
Enter->top++;
Enter->stack[Enter->top]=Temp->stack[Temp->top];
Temp->stack[Temp->top]=NULL;
Temp->top--;
}
PRINT(p,room);
/*判断通道上是否有车及车站是否已满*/
if((W->head!=W->rear)&&Enter->top<PACKSIZE) /*便道的车辆进入车场*/
{
q=W->head->next;
t=q->data;
Enter->top++;
printf("\nThe car numbered %s enter the positon %d in the Cpark ",t->num,Enter->top);
printf("\nPlease input the current time/**:**/:");
scanf("%d:%d",&(t->reach.hour),&(t->reach.min));
W->head->next=q->next;
if(q==W->rear) W->rear=W->head;
Enter->stack[Enter->top]=t;
free(q);
}
else printf("\nThere is no car on the Road\n");
}
else printf("\nThere is no car in the Cpark."); /*没车*/
}
void List1(Cpark *S) /*列表显示车场信息*/
{
int i;
if(S->top>0) /*判断车站内是否有车*/
{
printf("\nCpark:");
printf("\n Reachtime Carnum\n");
for(i=1;i<=S->top;i++)
{
printf(" %d ",i);
printf("%d:%d ",S->stack[i]->reach.hour,S->stack[i]->reach.min);
puts(S->stack[i]->num);
}
}
else printf("\nThere is no car in the Cpark");
}
void List2(Road *W) /*列表显示便道信息*/
{
car *p;
p=W->head->next;
if(W->head!=W->rear) /*判断通道上是否有车*/
{
printf("\nThe number of the car which waited is:");
while(p!=NULL)
{
puts(p->data->num);
p=p->next;
}
}
else printf("\nThere is no car on the road.");
}
void List(Cpark S,Road W)
{
int flag,tag;
flag=1;
while(flag)
{
printf("\nPlease choose 1|2|3:");
printf("\n1.Cpark\n2.Road\n3.return\n");
while(1)
{
scanf("%d",&tag);
if(tag>=1||tag<=3) break;
else printf("\nplease choose: 1|2|3:");
}
switch(tag)
{
case 1:List1(&S);break; /*列表显示车场信息*/
case 2:List2(&W);break; /*列表显示便道信息*/
case 3:flag=0;break;
default: break;
}
}
}
这个代码有点小bug,就是在车辆离开时，它并不是输出钱数，而是出现一个死循环，也就是void Leave(Cpark *Enter,Cpark *Temp,Road *W)这部分有错误，哪位高手帮忙改一下啊，拜托了，呵呵

堆栈头文件(SeqStack.h):

typedef struct //车开入信息
{
int number;
int time;
}car;

typedef car Data_Stack;

typedef struct //储存车场内信息
{
Data_Stack stack[MaxStackSize];
int top;
}SeqStack;

void StackInit(SeqStack *S) //初始化车场
{
S->top=0;
}

int StackPush(SeqStack *S,Data_Stack d) //进入车场
{
if(S->top>=MaxStackSize)
{
printf("堆栈已满,无法插入\n");
return 0;
}
S->stack[S->top]=d;
S->top++;
return 1;
}

int StackPop(SeqStack *S,Data_Stack *d) //开出车场
{
if(S->top<=0)
{
printf("堆栈为空,出栈失败\n");
return 0;
}
S->top--;
*d=S->stack[S->top];
return 1;
}

int StackFind(SeqStack *S,int d) //查找车所在的位置
{
int i=0;
while(i<S->top)
{
if(S->stack[i].number==d)
return(i);
i++;
}
printf("该车不存在\n");
return(-1);
}

队列头文件(LQNode.h):

typedef int Data_Queue; //记录车牌号
typedef struct qnode //车的信息和下一辆车
{
Data_Queue number;
struct qnode *next;
}LQNode;

typedef struct //记录车道中的首尾车
{
LQNode *front;
LQNode *rear;
int count;
}LQueue;

void QueueInit(LQueue *Q) //初始化车道
{
Q->front=NULL;
Q->rear=NULL;
Q->count=0;
}

int QueueAppend(LQueue *Q,Data_Queue d) //入车道
{
LQNode *p;
if((p=(LQNode *)malloc(sizeof(LQNode)))==NULL)
{
printf("内存不足\n");
return 0;
}
p->number=d;
p->next=NULL;
if(Q->rear!=NULL)
Q->rear->next=p;
Q->rear=p;
if(Q->front==NULL)
Q->front=p;
Q->count++;
return 1;
}

int QueueDelete(LQueue *Q,Data_Queue *d) //出车道
{
LQNode *p;
if(Q->front==NULL)
{
printf("队列已空,出队列失败\n");
return 0;
}
*d=Q->front->number;
p=Q->front;
Q->front=Q->front->next;
if(Q->front==NULL)
Q->rear=NULL;
free(p);
Q->count--;
return 1;
}

void DestroyQueue(LQueue *Q)
{
LQNode *p,*q;
p=Q->front;
while(p!=NULL)
{
q=p;
p=p->next;
free(q);
}
}

主体部分:

/****************************************************************

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

*****************************************************************/

#include<stdio.h>
#include<stdlib.h>

#define MaxStackSize 2 //车场可放车辆数
#define PRICE 5 //每单位时间收费PRICE
#include"SeqStack.h"
#include"LQNode.h"

typedef struct
{
char imformation;
int number;
int time;
}Data;

Data enter() //用来输入测试数据
{
Data dt;
fflush(stdin);
scanf("%c",&dt.imformation);
scanf("%d",&dt.number);
scanf("%d",&dt.time);
return(dt);
}

void PrintStack(SeqStack S)
{
int i;
Data_Stack d;
i=S.top;
while(i)
{
d=S.stack[--i];
printf("%d号车在车场内的位置是第%d个,进场时间为%d\n",d.number,i+1,d.time);
}
}

void PrintQueue(LQueue *Q)
{
LQNode *p1;
int i=1;
p1=Q->front;
while(p1!=NULL)
{
printf("%d号车在车道内的位置是第%d个\n",p1->number,i++);
p1=p1->next;
}
}

int main() //入口函数
{
int i;
Data d;
Data_Stack ds;
Data_Queue dq;
SeqStack S; //用来储存车场里的车的信息
SeqStack S2; //用来储存临时停放为给要离去的汽车让路而从停车场退出来的汽车的信息
LQueue Q; //用来储存在车道里排队的车的信息
StackInit(&S); //初始化S
StackInit(&S2);
QueueInit(&Q);
printf("系统信息如下:\n\tA表示进入\n\tD表示开出\n\t输入信息类似如下A 1 15\n\t第一个表示开入开出信息,第二个为车牌号,第三个为开入或开出时间\n\n");
while((d=enter()).imformation!='E') //输入的信息为E时退出系统
{
if(d.imformation=='A') //进入时
{
if(S.top<MaxStackSize)
{ //车场未满
ds.number=d.number;
ds.time=d.time;
StackPush(&S,ds);
printf("\n车场,车道的情况为:\n");
PrintStack(S);
PrintQueue(&Q);
printf("\n\n\n");
}
else //车场已满
{
dq=d.number;
QueueAppend(&Q,dq);
printf("\n车场,车道的情况为:\n");
PrintStack(S);
PrintQueue(&Q);
printf("\n\n\n");
}
}
else if(d.imformation=='D') //开出时
{
if((i=StackFind(&S,d.number))>=0) //查找开出的车的信息
{
printf("\n%d号车进场时间为%d,出场时间为%d\n",d.number,S.stack[i].time,d.time);
printf("%d号车停留时间为%d,应缴费%d\n",S.stack[i].number,d.time-S.stack[i].time,(d.time-S.stack[i].time)*PRICE);
for(;i<S.top-1;i++) //让路
{
StackPop(&S,&ds);
StackPush(&S2,ds);
}
StackPop(&S,&ds); //开出
while(S2.top>0) //让路的车开进车场
{
StackPop(&S2,&ds);
StackPush(&S,ds);
}
if(Q.count!=0)
{
QueueDelete(&Q,&dq); //车从车道开出
ds.number=dq;
ds.time=d.time;
StackPush(&S,ds); //开进车场
printf("\n%d号车开进车场\n",ds.number);
}
printf("\n车场,车道的情况为:\n");
PrintStack(S);
PrintQueue(&Q);
printf("\n\n\n");
}
}
}
DestroyQueue(&Q); //清空车道
return 0;
}
/*********************************************************
测试数据:(操作信息:进入用A表示,出去用D表示,每一行输入操作信息,车牌号,进入时间或出去时间.用空格分开)
A 1 5

车场,车道的情况为:
1号车在车场内的位置是第1个,进场时间为5

A 2 10

车场,车道的情况为:
2号车在车场内的位置是第2个,进场时间为10
1号车在车场内的位置是第1个,进场时间为5

D 1 15

1号车进场时间为5,出场时间为15
1号车停留时间为10,应缴费50

车场,车道的情况为:
2号车在车场内的位置是第1个,进场时间为10

A 3 20

车场,车道的情况为:
3号车在车场内的位置是第2个,进场时间为20
2号车在车场内的位置是第1个,进场时间为10

A 4 25

车场,车道的情况为:
3号车在车场内的位置是第2个,进场时间为20
2号车在车场内的位置是第1个,进场时间为10
4号车在车道内的位置是第1个

A 5 30

车场,车道的情况为:
3号车在车场内的位置是第2个,进场时间为20
2号车在车场内的位置是第1个,进场时间为10
4号车在车道内的位置是第1个
5号车在车道内的位置是第2个

D 2 35

2号车进场时间为10,出场时间为35
2号车停留时间为25,应缴费125

4号车开进车场

车场,车道的情况为:
4号车在车场内的位置是第2个,进场时间为35
3号车在车场内的位置是第1个,进场时间为20
5号车在车道内的位置是第1个

D 4 40
4号车进场时间为35,出场时间为40
4号车停留时间为5,应缴费25

5号车开进车场

车场,车道的情况为:
5号车在车场内的位置是第2个,进场时间为40
3号车在车场内的位置是第1个,进场时间为20

E 0 0
Press any key to continue

另外其实还要额外建立一个队列,用来储存在车道中出去的车,和从车场出去差不多,只不过要将队列中的元素全部出列,除了要出道的外,其余依次进入额外队列中,然后再进车道.我没有写,你自己写吧