苏嵌学习日志day4

name：钱成杰
date：2018.9.13
今日学习任务
编写程序：1.车辆出栈2.出去的车进来3.等候队列进来。顺序结构是有容量的，停车场的初步设计，分为：停车栈，让路栈，等候车栈，等候车栈是链式存储
今日任务完成情况
上课能跟上老师教学进度，完成程序的编写。在编程的过程中将定义语句#define写成了#include，在编程过程中还出现了简单的程序遗漏，在老师的帮助下已成功解决。
今日开发中出现的问题汇总
顺序结构是有容量的，停车场的初步设计，分为：停车栈，让路栈，等候车栈，等候车栈是链式存储。
注意：gcc *.c -o Wall 生成的文件是Wall
gcc *.c -Wall 生成文件a.out
今日未解决问题
停车场中进车没有问题，停车有问题还需要解决
今日开发收获
了解了停车场停车系统的初步构成及进车出车的流程
自我评价
老师讲的很好，受益匪浅。自己还需要多加练习。

课堂训练：

Park.h
#ifndef PARK_H
#define PARK_H

#include  <time.h>
#include <string.h>

#define MAXSIZE 5
#define SUCCESS 1000
#define FAILURE 1001
#define FULL    1002
struct carinfo
{
   char number[10];  //车牌号
   time_t park_time; //进场时间
   struct carinfo *next; //指向下一辆车
};
typedef struct carinfo car;

struct stackinfo
{
     car data[MAXSIZE]; //结构体数组
     int top;
};
typedef struct stackinfo stack;

struct queueinfo
{
   car *front; //队头指针
   car *rear;  //队尾指针
};
typedef struct queueinfo queue;

void welcome();
void menu();
void bye();
void Init(stack *s1 ,stack *s2,queue *q);
int InitStack(stack *s);
int InitQueue(queue *q);
void Enterpark(stack *s,queue *q);
int push(stack *s,char *id);
int EnterQueue(queue *q,char *id);
void Showparkinfo(stack *s);
void ShowWaitInfo(queue *q);
int EmptyQueue(queue *q);
void Leavepark(stack*s1,stack *s2,queue *q);
car pop(stack *s);
int EmptyStack(stack *s);
char *DelQueue(queue *q);
#endif




Main.c
#include"park.h"
#include"stdio.h"

int main()
{    
     int choice;
     stack park_stack,leave_stack;   //停车让路线
     queue wait_queue;             //等候队列

      welcome();

     Init(&park_stack,&leave_stack,&wait_queue);  //初始化


    while(1)
    {
       menu();
        scanf("%d",&choice);
        switch(choice)
        {
           case 1:
               Enterpark(&park_stack,&wait_queue);
                  break;
           case 2:
                   Leavepark(&park_stack,&leave_stack,&wait_queue);
                  break;

           case 3:
                   Showparkinfo(&park_stack);
                  break;
           case 4:
                    ShowWaitInfo(&wait_queue);
                  break;
           case 5:
                  bye();
                  break;
           default:
                 printf("输入有误\n");
                  break;

        }
    }




  return 0;
}
Park.c
#include"park.h"
#include"stdio.h"
#include "unistd.h"
#include <stdlib.h>

 void welcome()
{
   system ("clear");

   printf("\n\n\n");
   printf("\t\t******************\n");
   printf("\t\t******WELCOME*****\n");
   printf("\t\t******************\n");

   sleep(2);

}

     void menu()
     {
        system("clear");
        printf("\n\n\n");
        printf("\t\t1、停车\n");
        printf("\t\t2、出车\n");
        printf("\t\t3、查看场内车辆信息\n");
        printf("\t\t4、查看等候车辆信息\n");
        printf("\t\t5、退出系统\n");
        printf("请输入你的选择");
     }


     void bye()
     {
       system("clear");
       printf("\n\n\n\n\t\t\t\tbyebye...\n");
       sleep(1);
       system("clear");
       exit(1);

     }

     void Init(stack *s1 ,stack *s2,queue *q)
     {
         int ret;
         ret=InitStack(s1);  //初始化停车栈
         if(FAILURE==ret)
         {
         printf("Init Stack Failure!\n");
         }

          ret=InitStack(s2); //初始化让路栈
         if(FAILURE==ret)
         {
         printf("Init Stack Failure!\n");
         }

          ret=InitQueue(q); //初始化等候车栈
         if(FAILURE==ret)
         {
         printf("Init Queue Failure!\n");
         }

     }

     void Enterpark(stack *s,queue *q)
     {    char id[10]={0};
        if(NULL==s||NULL==q)
        {
        return;
        }
        printf("请输入车牌号");
        scanf("%s",id);

        int ret=push(s,id);
        if(ret==FAILURE)
        {
            printf("进场失败!\n");
        }
        else if(ret==FULL)
        {
            printf("停车场已满，进入等候队列\n");
             sleep(1);
             EnterQueue(q,id);  //把车停放在等候队列里面
        }
        else
        {
          printf("停车成功\n");
          sleep(1);
        }
     }
     void Showparkinfo(stack *s)
     {   
     int i;
       if(NULL==s)
       {
         return;
       }
       for(i=0;i<=s->top;i++)
       {
          printf("车牌号: %s\n",s->data[i].number);
          printf("停车时长: %d\n",(int)(time(NULL)-s->data[i].park_time));
          printf("*****\n");
       }

       printf("Press Enter Continue....\n");
       getchar();
       getchar();

     }

     void ShowWaitInfo(queue *q)
     {
        if(NULL==q)
        {
          return;
        }
        if(EmptyQueue(q)==SUCCESS)
        {
          printf("等候队列没有车辆\n");
          sleep(1);
        }
        else
        {
           car *p=q->front->next;
           while(p)
           {
              printf("车牌号: %s\n",p->number);
              p=p->next;  //指针p指向下一辆车
           }
           printf("Press Enter Continue...\n");
           getchar();
           getchar();

        }
     }

     void Leavepark(stack*s1,stack *s2,queue *q)
     {
        int i;
        char id[10]={0};
        if(NULL==s1||NULL==s2||NULL==q)
        {
           return;

        }

        printf("请输入车牌号:\n");
        scanf("%s",id);

          int length=s1->top;

        for(i=0;i<=length;i++)
        {
           if(!strcmp(id,s1->data[s1->top].number))   //匹配到车辆
           {  
             pop(s1);     //  匹配到的车辆出栈

               while(EmptyStack(s2)!=SUCCESS)
               {
                  car c=pop(s2);     //从让路栈出来 
                  push(s1,c.number); //进入停车栈
               }

                //如果等候队列不为空 则第一辆车进栈
              if( EmptyQueue(q)!=SUCCESS)
              {
                 char *id =DelQueue(q);
                 push(s1,id);
                 free(id);
              }
                break;
            }
            else
            {
                 car c=pop(s1);       //不匹配则出栈并且进入让路栈
                push(s2,c.number);     
            }
        }


     }
Queue.c
#include"park.h"
#include"stdlib.h"
#include "string.h"

/*初始化队列*/
int InitQueue(queue *q)
{
   if(NULL==q)
   {
     return FAILURE;
   }

   car *p=(car *)malloc(sizeof(car));
   if(NULL==p)
   {
     return FAILURE;
   }

   p->next=NULL;
   q->front =q->rear=p;

   return SUCCESS;

}

int EnterQueue(queue *q,char *id)
{
    if(NULL==q||NULL==id)
    {
       return FAILURE;
    }

    car *p =(car *)malloc(sizeof(car));
    if(NULL==p)
    {
       return FAILURE;
    }

    strcpy(p->number,id);
    p->next=NULL;

    q->rear->next =p;
    q->rear=p;
    return SUCCESS;
}
  //入参判断 判断队列是否为空
 int EmptyQueue(queue *q)
 {
    if(NULL==q)
    {
       return FAILURE;
    }
    else
    {
       return(q->front==q->rear)?SUCCESS:FAILURE;
    }
 }
   //出队操作，返回车牌号
 char *DelQueue(queue *q)
 {
    if(NULL==q)
    {
       return NULL;
    }
    char *id =(char *)malloc(sizeof(char)* 10);
    car *c =q->front->next;
    if(c!=NULL)
    {
        strcpy(id,c->number);   //保存车牌号
       q->front->next =c->next;
       free(c);
    }

    if(c==q->rear)   //如果队列只剩一辆车
    {
       q->rear=q->front;
    }

    return id;
 }

Stack.c
#include"park.h"
#include"string.h"

int InitStack(stack *s)
{
    if(NULL==s)
    {
      return FAILURE;
    }
    s->top =-1;

    return SUCCESS;

}
int push(stack *s,char *id)
{
  if(NULL==s)
  {
    return FAILURE;
  }

  if(s->top==MAXSIZE-1)
  {
     return FULL;
  }

  strcpy(s->data[s->top+1].number,id);  //拷贝车牌号
  s->data[s->top+1].park_time=time(NULL); //记录进场时间
  s->top++;

  return SUCCESS;

}
//出栈操作
car pop(stack *s)
{
   car c;

  if(NULL==s)
  {
      return c;
  }

     if(s->top==-1)
     {
         return c;
     }

    strcpy(c.number,s->data[s->top].number);
    c.park_time =s->data[s->top].park_time;

    s->top--;
    return c;
}

int EmptyStack(stack *s)
{
   if(NULL==s)
   {
     return FAILURE;
   }
   return (s->top==-1)?SUCCESS:FAILURE;
}