这不是典型的栈的吗？照着那个思路做不就行了

典型的数据结构算法
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
/*------------------------------------------------------------------------------*/
#define MAX 2 /*车库容量*/
#define price 0.05 /*每车每分钟费用*/
typedef struct time{
int hour;
int min;
}Time; /*时间结点*/
typedef struct node{
char num[10];
Time reach;
Time leave;
}CarNode; /*车辆信息结点*/
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; /*模拟通道*/
/*------------------------------------------------------------------------------*/
void InitStack(SeqStackCar *); /*初始化栈*/
int InitQueue(LinkQueueCar *); /*初始化便道*/
int Arrival(SeqStackCar *,LinkQueueCar *); /*车辆到达*/
void Leave(SeqStackCar *,SeqStackCar *,LinkQueueCar *); /*车辆离开*/
void List(SeqStackCar,LinkQueueCar); /*显示存车信息*/
/*------------------------------------------------------------------------------*/
void main()
{
SeqStackCar Enter,Temp;
LinkQueueCar Wait;
int ch;
InitStack(&Enter); /*初始化车站*/
InitStack(&Temp); /*初始化让路的临时栈*/
InitQueue(&Wait); /*初始化通道*/
while(1)
{
printf("\n1. the car arrive");
printf(" 2. the car leave");
printf(" 3. the schedule ");
printf(" 4. out\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(SeqStackCar *s) /*初始化栈*/
{
int i;
s->top=0;
for(i=0;i<=MAX;i++)
s->stack[s->top]=NULL;
}
int InitQueue(LinkQueueCar *Q) /*初始化便道*/
{
Q->head=(QueueNode *)malloc(sizeof(QueueNode));
if(Q->head!=NULL)
{
Q->head->next=NULL;
Q->rear=Q->head;
return(1);
}
else return(-1);
}
void PRINT(CarNode *p,int room) /*打印出站车的信息*/
{
int A1,A2,B1,B2;
printf("\nplease input thedepart time:/**:**/");
scanf("%d:%d",&(p->leave.hour),&(p->leave.min));
printf("\nthe number of the car:");
puts(p->num);
printf("\nthe time the car arrive: %d:%d",p->reach.hour,p->reach.min);
printf("the depart 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 fee: %2.1f元",((B1-A1)*60+(B2-A2))*price);
free(p);
}
int Arrival(SeqStackCar *Enter,LinkQueueCar *W) /*车辆到达*/
{
CarNode *p;
QueueNode *t;
p=(CarNode *)malloc(sizeof(CarNode));
flushall();
printf("\ninput the number of the car:");
gets(p->num);
if(Enter->top<MAX) /*车场未满，车进车场*/
{
Enter->top++;
printf("\nthe place of the car.",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("\n该车须在便道等待!");
t=(QueueNode *)malloc(sizeof(QueueNode));
t->data=p;
t->next=NULL;
W->rear->next=t;
W->rear=t;
return(1);
}
}
void Leave(SeqStackCar *Enter,SeqStackCar *Temp,LinkQueueCar *W)
{ /*车辆离开*/
int i, room;
CarNode *p,*t;
QueueNode *q;
/*判断车场内是否有车*/
if(Enter->top>0) /*有车*/
{
while(1) /*输入离开车辆的信息*/
{
printf("\n请输入车在车场的位置/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<MAX) /*便道的车辆进入车场*/
{
q=W->head->next;
t=q->data;
Enter->top++;
printf("\n便道的%s号车进入车场第%d位置.",t->num,Enter->top);
printf("\n请输入现在的时间/**:**/:");
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("\n便道里没有车.\n");
}
else printf("\n车场里没有车."); /*没车*/
}
void List1(SeqStackCar *S) /*列表显示车场信息*/
{
int i;
if(S->top>0) /*判断车站内是否有车*/
{
printf("\n车场:");
printf("\n 位置 到达时间 车牌号\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("\n车场里没有车");
}
void List2(LinkQueueCar *W) /*列表显示便道信息*/
{
QueueNode *p;
p=W->head->next;
if(W->head!=W->rear) /*判断通道上是否有车*/
{
printf("\n等待车辆的号码为:");
while(p!=NULL)
{
puts(p->data->num);
p=p->next;
}
}
else printf("\n便道里没有车.");
}
void List(SeqStackCar S,LinkQueueCar W)
{
int flag,tag;
flag=1;
while(flag)
{
printf("\n请选择 1|2|3:");
printf("\n1.车场\n2.便道\n3.返回\n");
while(1)
{
scanf("%d",&tag);
if(tag>=1||tag<=3) break;
else printf("\n请选择 1|2|3:");
}
switch(tag)
{
case 1:List1(&S);break; /*列表显示车场信息*/
case 2:List2(&W);break; /*列表显示便道信息*/
case 3:flag=0;break;
default: break;
}
}
}

#include "stdio.h"
#define A 5 /* 停车单价 */
#define TRUE 1
#define FALSE 0
#define NULL 0
#define Stack_Size 5 /* 车库容量 */
typedef struct
{
int elem1[Stack_Size];
int elem2[Stack_Size];
int top;
}SeqStack; /* 定义栈的结构体 */
typedef struct Node
{
int num;
int time;
struct Node *next;
}LinkQueueNode; /* 定义链队列结点的结构体 */
typedef struct
{
LinkQueueNode *front;
LinkQueueNode *rear;
}LinkQueue; /* 定义链队列的结构体*/
InitQueue(LinkQueue *Q) /* 初始化链队列函数 */
{
Q->front=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));
if(Q->front!=NULL)
{
Q->rear=Q->front;
Q->front->next=NULL;
return(TRUE);
}
else return(FALSE);
}
EnterQueue(LinkQueue *Q,int x,int y) /* 入链队列函数 */
{
LinkQueueNode *NewNode;
NewNode=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));
if(NewNode!=NULL)
{
NewNode->num=x;
NewNode->time=y;
NewNode->next=NULL;
Q->rear->next=NewNode;
Q->rear=NewNode;
return(TRUE);
}
else return(FALSE);
}
DeleteQueue(LinkQueue *Q,int *x,int *y) /* 删除链队列结点函数 */
{
LinkQueueNode *p;
if(Q->front==Q->rear)
{
return(FALSE);
}
p=Q->front->next;
Q->front->next=p->next;
if(Q->rear==p)
{
Q->rear=Q->front;
}
*x=p->num;
*y=p->time;
free(p);
return(TRUE);
}
InitStack(SeqStack *S) /* 初始化栈 */
{
S->top=-1;
}
Push(SeqStack *S,int x,int y) /* 栈插入函数 */
{
S->top++;
S->elem1[S->top]=x;
S->elem2[S->top]=y;
return(TRUE);
}
Pop(SeqStack *S,int *x,int *y) /* 栈删除函数 */
{
if(S->top==-1)
{
return(FALSE);
}
else {
*x=S->elem1[S->top];
*y=S->elem2[S->top];
S->top--;
return(TRUE);
}
}
IsFull(SeqStack *S) /* 判断栈满函数 */
{
return(S->top==Stack_Size-1?TRUE:FALSE);
}
IsEmpty(SeqStack *S) /* 判断栈满函数 */
{
return(S->top==-1?TRUE:FALSE);
}
choose() /* 选择函数 */
{
int m;
printf("\nooooooooo\nPlease choose:\n1. in; 2. out; 3. exit.\n");
scanf("%d",&m);
if(m==1||m==2)
{
return(m);
}
if(m==3)
{
exit(0); /* 整个程序由此结束 */
}
else
{
printf("Choose is wrong!");
exit(1);
}
}
main()
{
int m,num,pp=1,time,k=0,p=0,x,y,t;
LinkQueue *Q;
SeqStack *S,*R;
InitQueue(Q);
InitStack(R);
InitStack(S);
while(pp!=0) /* 控制程序一直循环 */
{ m=choose(); /* 整个程序由此进 */
printf("Please enter the NUMBER of the car:\n ");
scanf("%d",&num);
printf("Please enter the TIME:\n ");
scanf("%d",&time);
if(m==1)
{
printf("The No.%d car stands at ",num);
if(IsFull(S)) /* 先判断车库是否满了 */
{
EnterQueue(Q,num,time); /* 如果满了,则放入便道里(链队列) */
k++; /* 便道里的位置计数器 */
printf("%dth in the biandao.\n",k);
}
else
{
Push(S,num,time); /* 如果不满,则放入车库里(顺序栈) */
p++; /* 车库里的位置计数器 */
printf("%dth in the STOP!\n",p);
}
}
if(m==2)
{ if(IsEmpty(S)) /* 判断车库还有车吗,其作用为防止非法输入 */
{ printf("The STOP is empty,No.%d isn't here!",num);
exit(2);
}
while(num!=S->elem1[S->top]) /* 寻找所要出的车 */
{
Pop(S,&x,&y); /* 车库最外辆车出库 */
while(p>0)
{
p--; /* 出车则减一个数 */
}
Push(R,x,y); /* 将刚出的车如临时车库(顺序栈) */
}
Pop(S,&x,&y); /* 找到车后将其弹出 */
p--; /* 出车则减一个数 */
t=time-y; /* 计算其停车时间 */
printf("The No.%d car stopped for %d minutes.\nFrom %d to %d \n$:%d\n",num,t,y,time,t*A);
while(!IsEmpty(R))
{
Pop(R,&x,&y);
Push(S,x,y);
p++;
} /* 将临时车库的车全部转到车库 */
if(Q->front!=Q->rear) /* 判断便道是否有车 */
{ DeleteQueue(Q,&x,&y); /* 如果有则出便道 */
Push(S,x,y); /* 进车库 */
p++; /* 车库计数器加1 */
k--; /* 便道计数器减1 */
}
}
}
}

4楼的程序有问题啊，输入时间后，就break了

Way.h
const int SIZE = 20;
const int INCREMENT = 10;
struct Car
{ int NO;
int time;
};

//队列
template <class T>
class Queue
{
private:
T *base;
int max_size;
int head,tail;
public:
Queue();
~Queue();
void InQue(T elem);
T* OutQue();
};

//栈
template <class U>
class Stack
{
private:
U *base;
int max_size;
int top;
public:
Stack(){;}
~Stack(){;}
void Set(int n);
void Pop();
void Push(U elem);
bool IsEmpty();
bool IsFull();
U* GetTop();
};

//Park
class Park
{
private:
Car car;
Stack<Car> ParkedCar;
Stack<Car> OutCar;
Queue<Car> Road;
int n,Mon;
public:
Park(){;}
bool Search();
void manage();
void PrintBill(Car &CurCar);
void Init();
void ParkIn();
};

Park.cpp
#include <iostream>
#include "Way.h"
using namespace std;
//Park
void Park::Init()
{
cout << "请输入车站最大停车数和每单位时间应收费：" <<endl;
cin >> n >> Mon;
ParkedCar.Set(n);
OutCar.Set(n);
}
void Park::manage()
{
cout << "请输入数据：" <<endl;
char Inf;
Car *temp;
do
{
cin >> Inf >> car.NO >> car.time;
switch (Inf)
{
case 'A' : ParkIn();
break;
case 'D' : if(!Search()) continue;
PrintBill(*ParkedCar.GetTop());
ParkedCar.Pop();
while(!ParkedCar.IsFull())
{
if(!OutCar.IsEmpty())
{
temp = OutCar.GetTop();
OutCar.Pop();
ParkedCar.Push(*temp);
}
else
{
temp = Road.OutQue();
ParkedCar.Push(*temp);
}
}
break;
case 'E' : cout << endl;
}
}while(Inf != 'E');
}
void Park::PrintBill(Car &CurCar)
{
int TimeDif,Money;
TimeDif = car.time-CurCar.time;
Money = Mon*TimeDif;
cout << "该车停留的时间和应付的费用为：" <<TimeDif << '\t' << Money << '\n';
}
void Park::ParkIn()
{
int Number;
if(!ParkedCar.IsFull())
{
ParkedCar.Push(car);
Number = car.NO;
cout << "该车停在车库的第" << Number << "位" <<endl;
}
else
{
Road.InQue(car);
Number = car.NO;
cout << "该车停在候车道的第" << Number <<"位" <<endl;
}
}
bool Park::Search()
{
Car *temp;
if(ParkedCar.IsEmpty())
{
cout << "车库已空" <<endl;
return false;
}
while(car.NO != ParkedCar.GetTop()->NO && !ParkedCar.IsEmpty())
{

temp = ParkedCar.GetTop();
ParkedCar.Pop();
OutCar.Push(*temp);
}
if(ParkedCar.IsEmpty())
{
cout << "此车不在车库。" <<endl;
while(!OutCar.IsEmpty())
{
temp = OutCar.GetTop();
OutCar.Pop();
ParkedCar.Push(*temp);
}
return false;
}
return true;
}
//Queue
template <class T>
Queue<T>::Queue()
{
base = new T [SIZE];
max_size = SIZE;
head=tail=0;
}
template <class T>
Queue<T>::~Queue()
{
delete []base;
}
template <class T>
void Queue<T>::InQue(T elem)
{
if(tail==max_size)
{
T *temp = new T [max_size];
int i;
for(i=0;i<max_size;i++)
temp[i] = base[i];
delete []base;
base = new T [max_size + INCREMENT];
for(i=0;i<max_size;i++)
base[i] = temp[i];
delete []temp;
max_size += INCREMENT;
}
base[tail++]=elem;
}
template <class T>
T *Queue<T>::OutQue()
{
T *temp = &base[head++];
return temp;
}
//Stack
template <class U>
void Stack<U>::Set(int n)
{
max_size = n;
base = new U[max_size+1];
top = 0;
}
template <class U>
void Stack<U>::Pop()
{
if(top>0)top--;
else cout<<"The Stack is Empty!"<<endl;
}
template <class U>
void Stack<U>::Push(U elem)
{
if(top==max_size)
cout<<"The Stack is Full!"<<endl;
else base[++top] = elem;
}
template <class U>
U *Stack<U>::GetTop()
{
U *temp = &base[top];
return temp;
}
template <class U>
bool Stack<U>::IsEmpty()
{
return top==0;

}
template <class U>
bool Stack<U>::IsFull()
{
return top==max_size;
}
//main
int main()
{
Park park;
park.Init();
park.manage();
return 0;
}

#include "stdio.h"
#include "stdlib.h"
#define A 5                /* 停车单价 */
#define TRUE 1
#define FALSE 0
#define NULL 0
#define Stack_Size 5    /* 车库容量 */
typedef struct
{
    int elem1[Stack_Size];
    int elem2[Stack_Size];
    int top;
}SeqStack;                /* 定义栈的结构体 */
typedef struct Node
{
    int num;
    int time;
    struct Node *next;
}LinkQueueNode;            /* 定义链队列结点的结构体 */
typedef struct
{
    LinkQueueNode *front;
    LinkQueueNode *rear;
}LinkQueue;                /* 定义链队列的结构体*/
InitQueue(LinkQueue *Q) /* 初始化链队列函数 */
{
    Q->front=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));
    if(Q->front!=NULL)
    {
        Q->rear=Q->front;
        Q->front->next=NULL;
        return(TRUE);
    }
    else return(FALSE);
}
EnterQueue(LinkQueue *Q,int x,int y) /* 入链队列函数 */
{
    LinkQueueNode *NewNode;
    NewNode=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));
    if(NewNode!=NULL)
    {
        NewNode->num=x;
        NewNode->time=y;
        NewNode->next=NULL;
        Q->rear->next=NewNode;
        Q->rear=NewNode;
        return(TRUE);
    }
    else return(FALSE);
}
DeleteQueue(LinkQueue *Q,int *x,int *y) /* 删除链队列结点函数 */
{
    LinkQueueNode *p;
    if(Q->front==Q->rear)
    {
        return(FALSE);
    }
    p=Q->front->next;
    Q->front->next=p->next;
    if(Q->rear==p)
    {
        Q->rear=Q->front;
    }
    *x=p->num;
    *y=p->time;
    free(p);
    return(TRUE);
}
void InitStack(SeqStack *S)            /* 初始化栈 */
{
    S->top=-1;
}
int Push(SeqStack *S,int x,int y)    /* 栈插入函数 */
{
    S->top++;
    S->elem1[S->top]=x;
    S->elem2[S->top]=y;
    return(TRUE);
}
int Pop(SeqStack *S,int *x,int *y)    /* 栈删除函数 */
{
    if(S->top==-1)
    {
        return(FALSE);
    }
    else {
        *x=S->elem1[S->top];
        *y=S->elem2[S->top];
        S->top--;
        return(TRUE);
    }
}
int IsFull(SeqStack *S) /* 判断栈满函数 */
{
    return(S->top==Stack_Size-1?TRUE:FALSE);
}
int IsEmpty(SeqStack *S) /* 判断栈满函数 */
{
    return(S->top==-1?TRUE:FALSE);
}
int choose() /* 选择函数 */
{
    int m;
    printf("\n请选择:1. 停车; 2. 出车; 3. 退出  ");
    scanf("%d",&m);
    if(m==1||m==2)
    {
        return(m);
    }
    if(m==3)
    {
        exit(0); /* 整个程序由此结束 */
    }
    else
    {
        printf("选择错误!");
        exit(1);
    }
}
void main()
{
    int m,num,pp=1,time,k=0,p=0,x,y,t;
    LinkQueue *Q=(LinkQueue*)malloc(sizeof(LinkQueue));
    SeqStack *S=(SeqStack*)malloc(sizeof(SeqStack)),*R=(SeqStack*)malloc(sizeof(SeqStack));
    InitQueue(Q);
    InitStack(R);
    InitStack(S);
    while(pp!=0)                        /* 控制程序一直循环 */
    {
        m=choose();                        /* 整个程序由此进 */
        printf("请输入汽车号码:\n ");
        scanf("%d",&num);
        printf("请输入时间:\n ");
        scanf("%d",&time);
        if(m==1)
        {
            printf("No.%d 号汽车停在 ",num);
            if(IsFull(S))                        /* 先判断车库是否满了 */
            {
                EnterQueue(Q,num,time);            /* 如果满了,则放入便道里(链队列) */
                k++;                            /* 便道里的位置计数器 */
                printf("便道中的第 %d 号位置.\n",k);
            }
            else
            {
                Push(S,num,time);                /* 如果不满,则放入车库里(顺序栈) */
                p++;                            /* 车库里的位置计数器 */
                printf("停车场的第 %d 号位置!\n",p);
            }
        }
        if(m==2)
        {
            if(IsEmpty(S))                        /* 判断车库还有车吗,其作用为防止非法输入 */
            {
                printf("车库为空,No.%d 不在!",num);
                exit(2);
            }
            while(num!=S->elem1[S->top]) /* 寻找所要出的车 */
            {
                Pop(S,&x,&y);            /* 车库最外辆车出库 */
                while(p>0)
                {
                    p--;                /* 出车则减一个数 */
                }
                Push(R,x,y);            /* 将刚出的车入临时车库(顺序栈) */
            }
            Pop(S,&x,&y);                /* 找到车后将其弹出 */
            p--;                        /* 出车则减一个数 */
            t=time-y;                    /* 计算其停车时间 */
            printf("No.%d 的车停了 %d 分钟.\n从%d 到 %d \n$:%d\n",num,t,y,time,t*A);
            while(!IsEmpty(R))
            {
                Pop(R,&x,&y);
                Push(S,x,y);
                p++;
            }                            /* 将临时车库的车全部转到车库 */
            if(Q->front!=Q->rear)        /* 判断便道是否有车 */
            { DeleteQueue(Q,&x,&y);        /* 如果有则出便道 */
                Push(S,x,y);            /* 进车库 */
                p++;                    /* 车库计数器加1 */
                k--;                    /* 便道计数器减1 */
            }
        }
    }
}

好啊