停车场栈和队列的调用

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

#define MaxSize 5       //停车场的最大停车数
#define FEE 2  //每小时的收费标准
#define L    10000
#define M    20000
typedef int ElemType;

ElemType tmpnum=0; //用于暂存 开出车的信息
ElemType tmptime=0;

/*======================停车场=======================*/
typedef struct
{
 ElemType car_num[MaxSize];           //车牌号码
 ElemType car_time[MaxSize];          //停车时间
 int top;
}STACK;

/*========================便道=============================*/
typedef struct qnode //连队节点的类型
{
 ElemType car_num;
 ElemType car_time;
 struct qnode *next;
}QTYPT;

typedef struct qptr
{
 QTYPT *front;
 QTYPT *rear;
}SQUEUE;
SQUEUE LQ;

 

/*===================================调度函数================================*/

void sleep(int time);
void wait(char *string);
void displayhead(void);
int chackinput(STACK *S,int pnum);
int chacktime(STACK *S,int ptime);
void displayChange(STACK *S,ElemType pnum,int ptime);
int displaystats(STACK *S,int pinput);
int inbiandao(SQUEUE *SQ,STACK *S);
int inparkstation(STACK *S);
int OutParkingStation(SQUEUE *biandao,STACK *car,STACK *tmp);
int outparkstation(STACK *S1,STACK *TS,ElemType pnum);
int main(int argc,char* agv[]);

/*==============================栈操作函数========================================*/
void InitStack(STACK *S);
int Full(STACK *S);
int Push(STACK *S,ElemType num,ElemType time);
int Empty(STACK *S);
int Pop(STACK *S,ElemType *num,ElemType *time);
int GetTop(STACK *S,ElemType *num,ElemType *time);

/*=================================队列操作函数====================================*/
void InitQueue(SQUEUE *LQ);
int EnQueue(SQUEUE *LQ,ElemType num,ElemType time);
int CountQueue(SQUEUE *LQ);
int Empty_Q(SQUEUE *LQ);
int OutQueue(SQUEUE *LQ,ElemType *num,ElemType *time);
int GetHead(SQUEUE *LQ,ElemType *num,ElemType *time);

/*==================================Parking_Num=====================================*/

void InitStack(STACK *S)              //初始化栈
{
 S->top = -1;
}

int Full(STACK *S)                //满栈检验
{
 if(S->top==MaxSize-1)
 {
  //printf("/n Stack is full! Push");
  return 0;
 }
 return 1;
}

int Push(STACK *S,ElemType num,ElemType time)
{
 if(S->top==MaxSize-1)
 {
  printf("/n Stack is full! Push");
  return 0;
 }
 
 S->top++;
 S->car_num[S->top]=num;
 S->car_time[S->top]=time;
 return 1;
 
}

int Empty(STACK *S)
{
 return (S->top==-1 ? 1:0);
}

int Pop(STACK *S,ElemType *num,ElemType *time)
{
 if(Empty(S))
 {
  puts("Stack is free Pop");
  return 0;
 }
 *num=S->car_num[S->top];
 *time=S->car_time[S->top];
 S->top--;
 return 1;
}

int GetTop(STACK *S,ElemType *num,ElemType *time)
{
 if(Empty(S))
 {
  puts("Stack is free Gettop");
 }
 *num=S->car_num[S->top];
 *time=S->car_time[S->top];
 return 1;
}

/*======================================便道========================================*/

 

void InitQueue(SQUEUE *LQ)
{
 QTYPT *p=NULL;
 p=(QTYPT *)malloc(sizeof(QTYPT));
 p->next=NULL;
 LQ->front=LQ->rear=p;
}

int EnQueue(SQUEUE *LQ,ElemType num,ElemType time)
{
 QTYPT *s;
 s=(QTYPT *)malloc(sizeof(QTYPT));
 s->car_num=num;
 s->car_time=time;
 s->next=LQ->rear->next;
 LQ->rear->next=s;
 LQ->rear=s;
 return 1;
}

int CountQueue(SQUEUE *LQ)
{
 int i=1;
 QTYPT *mfront=NULL;
 QTYPT *mrear=NULL;
 
 mfront=LQ->front;
 mrear=LQ->rear;
 
 
        while(!(LQ->front==LQ->rear))
 {
  i++;
  LQ->front=LQ->front->next;
 }
 LQ->front=mfront;
 
 
 return i;
}

int Empty_Q(SQUEUE *LQ)
{
 return (LQ->front==LQ->rear?1:0);
}

int OutQueue(SQUEUE *LQ,ElemType *num,ElemType *time)
{
 QTYPT *p;
 if(Empty_Q(LQ))
 {
  puts("Quenue is free OutQuenue");
  return 0;
 }
 p=LQ->front->next;
 *num=p->car_num;
 *time=p->car_time;
 LQ->front->next=p->next;
 if(LQ->front->next==NULL)
 {
  LQ->rear=LQ->front;
 }
 free(p);
 return 1;
}

int GetHead(SQUEUE *LQ,ElemType *num,ElemType *time)
{
 if(Empty_Q(LQ))
 {
  puts("Quenue is free GetHead");
  return 0;
 }
 *num=LQ->front->next->car_num;
 *time=LQ->front->next->car_time;
 return 1;
}
/*===================SLEEPFUNCTON=============*/
void sleep(int time)
{
 clock_t goal;
 goal=time*(CLOCKS_PER_SEC)+clock();
 while(goal > clock())
 {
  ;
 }
}

/*=================CHACKING======================*/
int chackinput(STACK *S,int pnum)
{
 int i=0;
 int num;
 num = pnum;
 i=S->top;
 for(;!(i==-1);i--)
 {
               if(S->car_num[i]==num)
        {
                return 1;
        }
 }
 return 0;
}

/*==================CHACKINPUT TIME=================*/

int chacktime(STACK *S,int ptime)
{
 return S->car_time[S->top] <= ptime ? 1 : 0;
}

/*=================DISPLAY=====================*/
int displaystats(STACK *S,int pinput)
{
 int i = 0;

 i = S->top;

 switch(pinput)
 {
  case 10000:
  {
   if(!Empty(S))
   {
          for(;!(i==-1);i--)
          {
                                       printf("<===%d时%d号车停与%d车位===>/n",S->car_time[i],S->car_time[i],i+1);
          }
   }else{
    cout<<"停车场为空";
   }
   printf("还有车%d个位/n",MaxSize-S->top-1);
      
                break;
  }
  case 20000:
  {
   displayhead();
   break;
  }
  default:
  {
   return 1;
  }
 }
 
 return 0;
}

void displayhead(void)
{
 cout<<'/n'<<"<===============CT停车场管理系统===================>"<<endl;
 cout<<"<==操作说明:                   *******           ==>"<<endl;
 cout<<"<==A： 停车命令                *******           ==>"<<endl;
 cout<<"<==D： 出车命令                  ***             ==>"<<endl;
 cout<<"<==E： 退出程序                  ***             ==>"<<endl;
 cout<<"<==L:  显示停车场内状况     "<<endl;
 //cout<<"非主菜单输入 ‘20000’ 返回主菜单                "<<endl;
 cout<<"<==================================================>"<<endl;
}

void displayChange(STACK *S,ElemType pnum,int ptime)
{
 //system("color f0");
 printf("                                  (单价 %d元/小时 )/n",FEE);
        printf("<=======================电子收据===================>/n");
 printf("<==停车时间:--------------------------%d小时     ==>/n",ptime-tmptime);
 printf("<==车牌号码:--------------------------%d         ==>/n",tmpnum);
 printf("<==应收费用:--------------------------%d  元     ==>/n",(ptime-tmptime)*FEE);
 printf("<====================谢谢=欢迎下次再来=============>/n");
 printf("正在打印收据请稍等/n");
 for(int count=1; count < 1;count++)
 {
  printf("=");
  fflush(stdout);
  sleep(1);
 }
 printf(">/n");
 sleep(1);
}
/*=================Waint======================*/
void wait(char *string)
{
 printf("%s/n",string);
 for(int count=1; count < 1;count++)
 {
  printf("-");
         fflush(stdout);
  sleep(1);
 }
 printf(">/n");
 //sleep(1);

}
/*===============================利用临时栈出车函数============================*/
int outparkstation(STACK *S1,STACK *TS,ElemType pnum)
{
   int t_num=0;
   int t_time=0;

          while(1)
          {
           Pop(S1,&t_num,&t_time);
  if(t_num == pnum)
  {
   tmpnum=t_num; 
   tmptime=t_time;
   
   while(!Empty(TS))
   {
    Pop(TS,&t_num,&t_time);
                  Push(S1,t_num,t_time);
   }
  
   return 1;
  }
  
  Push(TS,t_num,t_time);
          }
          return 0;
}
/*==============================进入停车场==========================*/
int inparkstation(STACK *S)
{
  int parknum;
  int parktime;
 
  /*======================================*/
  printf("还有车%d个位/n",MaxSize-S->top-1);
         printf("请输入车牌号码:");
         cin>>parknum;                  
         while(chackinput(S,parknum))
         {                                                       
                printf("车牌号码重复，请输入%d1或者其他",parknum);
                cin>>parknum;                                    
         }
         printf("请输入停车时间:");
         cin>>parktime;
         printf("%d号车于%d时停泊在%d位/n",parknum,parktime,S->top+2);
         Push(S,parknum,parktime);
                   
       return 1; 
}
/*=============================进入便道===============================*/
int inbiandao(SQUEUE *SQ,STACK *S)
{
 
 int parknum ;
 
 printf("对不起,停车场已满，请您到便道等待.您将第");       
 printf("%d进入停车场/n",CountQueue(SQ));            
 printf("请输入车牌号码:");                                
 cin>>parknum;                                             
 while(chackinput(S,parknum))                           
 {                                                         
         printf("车牌号码重复，请输入%d1或者其他",parknum);
         cin>>parknum;                                     
 }                                                         
                                                           
                                                           
 EnQueue(SQ,parknum,0);                              
 
 
 return 1;
}                                                               
 

int OutParkingStation(SQUEUE *biandao,STACK *car,STACK *tmp)
{
 int parknum = 0;
 int parktime = 0;
 int buf=0;
 
 if(!Empty(car))
 {
        displaystats(car,10000);
        printf("请输入您要调出的车牌号码:");                  
        cin>>parknum;                                         
        while(!chackinput(car,parknum))                      
       {                                                     
         printf("没有您要查询的%d的车牌号码",parknum); 
         cin>>parknum;                                 
       }                                                     
                                                       
                                                       
       outparkstation(car,tmp,parknum);                    
                                                       
       printf("%d时%d号车进入停车场/n",tmptime,tmpnum);      
       printf("请输入现在的时间:");                          
       cin>>parktime;                                        
       while(!chacktime(car,parktime))                      
       {                                                     
         cout<<"输入时间小于停车时间，请重新输入:";    
         cin>>parktime;                                
                                                
       }
 
       displayChange(car,parknum,parktime);                                                              
 /*============================出车命令======================================*/                     
                                                                                      
       if(biandao->front==biandao->rear)                                                                    
       {                                                                                                  
       }else{                                                                                             
         printf("%d号车位空开/n",car->top+2);                                                        
         printf("%d时便道上的%d号汽车驶入%d号车位",parktime,biandao->front->next->car_num,car->top+2);
         OutQueue(biandao,&parknum,&buf);                                                          
         Push(car,parknum,parktime);                                                               
       }
      
       return 2;
  }           
 
  printf("停车场为空/n");                                                                                      
                                                                                                    
                                                                                                    
 return 1;                                                                                             
 

};       
/*================================MAINFUCTION=========================*/
int main(int argc,char* agv[])
{      
 char chance='A';        //菜单选择项
 
 STACK car;
 InitStack(&car);
 STACK tmp;
 InitStack(&tmp);
 SQUEUE biandao;
 InitQueue(&biandao);
loop:
 while(1)
 {
  system("color 0a");
  displayhead();
  cout<<"=>:";
  cin>>chance;
  
  
  /*========================SWITCH====================================*/
  switch(chance)
  {
          case 'A':      //停车
   {
    wait("正在查询车位，请稍等：");
                                if(Full(&car))        
                                {        
                                 inparkstation(&car);        //进入停车场
     
    }else{
     
                          inbiandao(&biandao,&car);   //进入便道
    }
           break;
   }
   case 'D':  //出车
   {
    OutParkingStation(&biandao,&car,&tmp);
    break;
   }
   case 'L':
   {
    displaystats(&car,10000);
    break;
   }
   case 'M':
   {
    displaystats(&car,20000);
    break;
   }
   case 'E':    //退出程序
   {
    wait("正在保存数据程序即将退出/n命令执行中:");  
    exit(0);
   }
          default:
   {
             cout<<"输入错误"<<endl;
           goto loop;
   }
  }
 }
 system("PAUSE");
 return 0;
}