栈与队列实现的停车场系统

停车场项目需求


问题描述：停车场是一个能放 n 辆车的狭长通道，只有一个大门，汽车按到达的先后次序停放。若车场满了，车要停在门
          外的便道上等候，一旦有车走，则便道上第一辆车进入。当停车场中的车离开时，由于通道窄，在它后面的车
 要先退出，待它走后在依次进入。汽车离开时按停放时间收费。
基本功能要求：
          （1）建立三个数据结构分别是：停放栈、让路栈、等候队列。
          （2）输入数据模拟管理过程，数据（入或出，车号）


功能描述：进车登记、出车登记、按车牌号查询停车车辆信息、查询出入车记录、
          查询场内车辆信息、查询等候车辆信息、退出系统。
          （1）linux系统编写（链表、栈、队列）；
          （2）进车登记：登记车牌号以及入场时间；
          （3）出车登记：计算出停车时间，记录车辆车牌；
          （4）按车牌号查询车辆信息：停车时间，是否来过停车场，是否还在停车场
          （5）查询出入记录：所有车辆，包括已经离开的
          （6）查询场内车辆信息：列出所有场内车辆信息
          （7）查询等候车辆信息：显示等候车辆数量以及所有车牌号

          （8）退出系统。

头文件：

/*****************************************************
    > File name: CarPark.h
    > Author: Mr.YUAN
    > 日期: 2017-11-27 19:13
*****************************************************/

#ifndef _CARPRAK_H_
#define _CARPARK_H_
#define MAXMUM 3
#define success 1003
#define failure 1000
#define Stack_Full 1001
#define PUSH_OK 1002

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

typedef struct CAR
{
    char num[10];
    time_t intime;
    time_t outtime;
    double expense;
    int length;
    int place;
}car;

typedef struct SeqStack
{
    car park[MAXMUM];
    int top;
}stack;

typedef struct node
{
    car data;
    struct node *next;
}Node;

typedef struct queue
{
    Node * front;
    Node * rear;
}car_queue;

int StackInit(stack *S);
int QueueInit(car_queue *Q);
int menu();
int Push1_Stack(stack *S,car *Car,car_queue *Q);
int in_queue(car_queue *p ,car *Car);
int Push_Stack1(stack *S,car *Car);
car *PopStack1(stack *S,car *Car);
int PopStack(stack *S,car *Car,car_queue *Q);
int Push_Stack(stack *S,car *Car,car_queue *Q);
int display_stack(stack *S);
int display_queue(car_queue *Q);



#endif

//接口函数
/*****************************************************
    > File name: CarPark.c
    > Author: Mr.YUAN
    > 日期: 2017-11-27 19:14
*****************************************************/


#include <stdio.h>
#include"CarPark.h"


int StackInit(stack *S)
{
    S->top = -1;
}


int QueueInit(car_queue *Q)
{
    Q->front = (Node*)malloc(sizeof(Node));
    Q->rear = Q->front;
    Q->front->next = NULL;
    if(NULL == Q->front)
        return failure;
}


int menu()
{
    int choice = 0;
    int ret = 0;


    printf("                     ===============================================\n");
    printf("                    |                                               |\n");
    printf("                    |          欢迎来到停车场管理系统               |\n");
    printf("                    |                                               |\n");
    printf("                     ===============================================\n");
    printf("                    | 1.停车                      2.取车            |\n");
    printf("                    | 3.查看停车场信息            4.查看等待区信息  |\n");
    printf("                    | 5.退出系统                                    |\n");
    printf("                    |===============================================\n");
    printf("                    | 收费标准：停车场按照10元/小时收费，未满1小    |\n");
    printf("                    | 时按1小时计算，等待区不收费！                 |\n");
    printf("                    |                                               |\n");
    printf("                    |===============================================|\n");
    printf("                    | 请输入你选择的功能.........                   |\n");
    printf("                    |-----------------------------------------------|\n");
    ret = scanf("%d",&choice);
    while(ret != 1 || (choice != 1 && choice != 2 && choice != 3 && choice != 4 && choice != 5
            && choice != 6))
            {
                printf("输入有误，请重新输入！\n");
                ret = scanf("%d",&choice);
            }
    if(choice == 1 || choice == 2 || choice == 3 || choice == 4 || choice == 5 || choice == 6)
        return choice;
}


int Push_Stack(stack *S,car *Car,car_queue *Q)
{   
    car_queue *p = Q;
    int   relay ;
    int ret;
    if(S->top == MAXMUM-1)
    {
         printf("停车场已满，是否进入等待区 ？（1/0）\n");
             scanf("%d",&relay);
         if(relay != 1 && relay != 0)
            printf("输入无效，请重新输入！\n");
         if(relay == 1)
         {
            ret = in_queue(p,Car);
            if(ret == success)
                printf("您的车已成功进入等待区！\n");
         }
         if(relay == 0)
            printf("您已放弃停车，请返回主界面退出系统，感谢您的使用！\n");
    }
    else
    {
        S->top++;
        S->park[S->top] = *Car;
        S->park[S->top].place = S->top + 1;
        time(&S->park[S->top].intime);
        return PUSH_OK;
    }
}


int in_queue(car_queue *Q,car *Car)
{
    Node *p = (Node *)malloc(sizeof(Node));
     if(p == NULL)
         printf("malloc p failure!\n");
     p->data = *Car;
     p->next = NULL;
     if(Q->rear == NULL)
     {
         Q->rear = p;
         Q->front->next = p;
     }
     else
     {
         Q->rear->next = p;
         Q->rear = p;
     }
     return success;
}


int Push_Stack1(stack *S,car *Car)
{
    S->top++;
    S->park[S->top] = *Car;


}


car *PopStack1(stack *S,car *Car)
{
    if(S->top != -1)
    {
        *Car = S->park[S->top];
        S->top--;
        return Car;
    }


}


int Push1_Stack(stack *S,car*Car,car_queue *Q)
{
    if(S->top != MAXMUM - 1)
        {
            S->top++;
            S->park[S->top] = *Car;
            S->park[S->top].place = S->top + 1;
            return success;
        }
}
int PopStack(stack *S,car *Car,car_queue *Q)
{
    char num[10];
    int i = 0;
    int flag = 0;
    int j = 0;
    int temp = 0;
    if(S->top == -1)
        printf("取车失败！\n");
    printf("请输入取的车牌号....\n");
    scanf("%s",num);
    while(i <= S->top)
    {
        temp = S->top;
        if((strcmp(num ,S->park[i].num) == 0) && S->park[i].place == i+1)
        { 
            if(i == S->top)
            {
                time(&(S->park[S->top].outtime));
                S->park[S->top].length = S->park[S->top].outtime - S->park[S->top].intime;
                S->park[S->top].expense = ((int)((S->park[S->top].length)/3600 + 1)*10);
                *Car = S->park[S->top];
                S->top--;
            }
            else
            {
                stack *q = (stack *)malloc(sizeof(stack));
                if(failure == StackInit(q))
                    printf("init stack failure!\n");
                j = i;


                while(j < temp)
                {
                    car *Car1 = (car *)malloc(sizeof(car));
                    *Car1 = S->park[S->top];
                    S->top--;
                    Push_Stack1(q,Car1);
                    j++;
                }
                time(&(S->park[S->top].outtime));
                S->park[S->top].length = S->park[S->top].outtime - S->park[S->top].intime;
                S->park[S->top].expense = ((int)((S->park[S->top].length)/3600 + 1)*10);
                *Car = S->park[S->top];
                S->top--;
                j = S->top;
                while(j < temp - 1)
                {
                    car *Car2 = (car*)malloc(sizeof(car));
                    car *newcar = (car*)malloc(sizeof(car));
                    newcar = PopStack1(q,Car2);
                    Push1_Stack(S,newcar,Q);
                    j++;
                }
            }
            flag = 1;
        }
        i++;
    }
    if(flag == 1)
    {
        printf("车已离开停车场，欢迎使用。\n");
        return success;
    }
    else
        printf("没有找到您的车，请确认车牌信息！\n");
}


int printf_check(car *Car)
{
    printf("\n");
    printf("车牌号：%s\n",Car->num);
    printf("停车时间：%s",ctime(&Car->intime));
    printf("取车时间：%s",ctime(&Car->outtime));
    printf("停车时长：%d分钟\n",(int)(Car->length/60+1));
    printf("停车费用：%.1f元\n",Car->expense);
}


int OutQueue(stack *S,car *Car,car_queue *Q)
{
    Node *a = Q->front->next;
    if(Q->front == Q->rear)
        return failure;
        
    if(S->top <= MAXMUM-1)
    {
        *Car = a->data;
        Q->front->next = a->next;
        if(Q->front->next == NULL)
            Q->rear = NULL;
        free(a);
        a = NULL;
        Push_Stack(S,Car,Q);
    }
    return success;
}


int display_stack(stack *S)
{
    int i = 0;
    time_t time_current;
    int length;
    time(&time_current);
    length = time_current - S->park[i].intime;


    if(S->top == -1)
    {
        printf("停车场没有车，无法查看车辆信息..\n");
        return -1;
    }
    while(i <= S->top)
    {
         printf("车牌号：%s\n",S->park[i].num);
         printf("停车时间：%s",ctime(&S->park[i].intime));
         printf("停车状态：使用中.....\n");
         printf("停车位：%d号车位\n",S->park[i].place);
         printf("当前使用时间：%d分钟\n",(int)(length/60)+1);
         printf("停车费用：0元\n",(int)((length/3600)+1)*10);
         printf("\n\n===============================================\n\n");
         i++;
    }
}


int display_queue(car_queue *Q)
{
    Node*p = Q->front->next;
    int i;


    if(p == NULL)
    {
        printf("目前没有车在等候区!\n");
        return 0;
    }
    while(p != NULL)
    {
        printf("车牌：%s\n",p->data.num);
        printf("等待排号:%d\n",++i);
        printf("\n=======

主函数



/*****************************************************
    > File name: Test_CarPark.c
    > Author: Mr.YUAN
    > 日期: 2017-11-27 19:14
*****************************************************/

#include <stdio.h>
#include "CarPark.h"
#include<time.h>
int main()
{
    stack *p,*q;
    car_queue *s;
    int ret;
    int choice;
    int a,i = 0;

   p = (stack*)malloc(sizeof(stack));
   q = (stack*)malloc(sizeof(stack));
   s = (car_queue*)malloc(sizeof(car_queue));
   ret = StackInit(p);
   if(failure == ret)
       printf("init stack1 failure!\n");
   ret = StackInit(q);
   if(failure == ret)
       printf("init stack2 failure!\n");
   ret = QueueInit(s);
   if(failure == ret)
       printf("init queue failure!\n");

    while(1)
    {
        system("clear");
        choice = menu();
        switch(choice)
        {
         case 1:
             {
                 system("clear");
                 car * Car = (car*)malloc(sizeof(car));
                 if(NULL == Car)
                     printf("malloc car failure!\n");
                 printf("请输入车辆相关信息.....\n");
                 scanf("%s",Car->num);
                 while(i <= p->top)
                 {
                     if(strcmp(Car->num,p->park[i].num) == 0)
                     {
                         printf("车牌号重复，请重新输入！\n");
                         scanf("%s",Car->num);
                     }
                     i++;
                 }
                ret = Push_Stack(p,Car,s);
                if(ret == PUSH_OK)
                {
                    printf("停车成功！停车号:%d,停车时间;%s",p->park[p->top].place,
                            ctime(&p->park[p->top].intime));
                }
                break;
             }
         case 2:
            {
                system("clear");
                car *Car1 = (car *)malloc(sizeof(car));
                if(NULL == Car1)
                    printf("malloc failure!\n");
                ret = PopStack(p,Car1,s);
                if(success == ret)
                {
                    printf("停车信息.....\n");
                    printf_check(Car1);
                    car *Car2 = (car *)malloc(sizeof(car));
                    if(NULL == Car2)
                        printf("malloc failure!\n");
                    ret = OutQueue(p,Car2,s);
                        if(s->front == s->rear)
                    if(ret == success)
                        printf("等待区1号车已进入！\n");
                }
                    break;
            }
         case 3:
            {
                system("clear");
                display_stack(p);
                break;
            }
         case 4:
            {
                system("clear");
                display_queue(s);
                break;
            }
         case 5:
            {
                system("clear");
                printf("谢谢使用！\n");
                exit(0);

            }
        }
        printf("\n\n按回车建返回主菜单........");
        getchar();
        getchar();
    }

    return 0;
}