C语言停车场管理系统，使用栈和队列实现

缺乏、安全感 2022-05-22 05:49 243阅读 0赞

# #

# 使用栈和队列实现的狭长停车场管理 #

--------------------

1、情况说明：   
（1）停车场结构为一条狭长的通道（可视为栈）。   
（2）若停车场内车辆已经停满，后来的车需要在路边排队等待，库内有车出来才能入库    （可视为队列）。   
（3）使用A代表入库，D代表出库，车辆信息包括入库时间和车牌。

--------------------

2、数据定义

#define M 3//车库能停几辆车，在这里定义
    //-----------------///--------------------///--------------------//
    typedef struct {
        int num;
        int ID;
        int arrivetime;
    }carinformation;
    //定义停车场的结构体
    typedef struct parkinglot {
        carinformation stack[M];
        int top;
    }carpark;//定义栈结构
    //-----------------///--------------------///--------------------//
    //--------------------///--------------------///--------------------//
    typedef struct carnode {
        int num;
        int ID;
        int arrivetime;
        //struct node *next;
    }qptr;
    //定义外面狭长路的队列
    typedef struct {
        qptr *front, *rear;
    }carqueue;
    //--------------------///--------------------///--------------------//

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26

3、初始化栈和队列函数

carpark *initstack()
    {
        carpark *T;
        T = (carpark *)malloc(sizeof(carpark));
        if (T == NULL)
        {
            /*地址分配错误直接退出程序，不能继续了*/
            system("cls");
            printf("\n\n\t因为内存空间问题，导致程序出错！即将退出！\n\n");
            system("pause");
            exit(0);
        }
        T->top = -1;
        return T;
    }
    //初始化停车场
    carqueue *initqueue()
    {
        carqueue *L;
        L = (carqueue *)malloc(sizeof(carqueue));
        L->front = (carqueue *)malloc(sizeof(carqueue));
        if (L == NULL||L->front == NULL)
        {
            /*地址分配错误直接退出程序，不能继续了*/
            system("cls");
            printf("\n\n\t因为内存空间问题，导致程序出错！即将退出！\n\n");
            system("pause");
            exit(0);
        }
        if (L->front == NULL);
        L->front->next = NULL;
        L->rear = L->front;
        return L;
    }
    //初始化路边停车位

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35

4、算法实现   
先上代码后解释：

/*
    下面是整个程序的核心内容
    主要实现了进入车库和路边等待的调用
    两个表的地址需要传过来
    车库表和路边队列表；
    carinter(char _array, int num, int time,carpark *P,carqueue *L)
    carinter(进库还是出库char A/D ,车牌号int , 到达时间int ,carpark *P 车库表 ,carqueue *L 路边表)
    */
    int carinter(char _array, int num, int time,carpark *P,carqueue *L)
    {
        if (_array == 'A')
        {
            if (parkfull(P) == 1)
            {
                int temp;
                //这里写车库满后进入队列的code
                printf("\t车牌为：%d的车辆，已进入路边等待！\n\n",num);
                temp = carroadsaid(time, num, L);
                if (temp == 0)
                {
                    /*地址分配错误直接退出程序，不能继续了*/
                    system("cls");
                    printf("\n\n\t因为内存空间问题，导致程序出错！即将退出！\n\n");
                    system("pause");
                    exit(0);
                }
                return 1;
            }
            else
            {
                int _top;
                printf("\t车牌为：%d的车辆，已进入车库！\n\n",num);
                _top = ++P->top;
                P->stack[_top].arrivetime = time;
                P->stack[_top].ID = num;
                P->stack[_top].num = internum++;
                return 1;
            }
        }
        else if (_array == 'D')
        {
            //这里是出库code
            outparking(num, time, P, L);
            return 2;//返回2，不清楚是否成功，只是返回一个数，错误在函数内判断
        }
        else//读取的char是个非法值，所以返回错误
        {
            return 0;
        }
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51

解释：   
（1）函数调用方法为：   
carinter(char \_array, int num, int time,carpark \*P,carqueue \*L)   
第一个参数char \_array为车辆是进入还是出去，第二个参数num是车牌号，第三个time是到达/离去时间（假设为int），后面两个参数为栈表和队列表的地址。   
（2）首先判断\_array是 A 入库还是 D 出库。如果为入库，就再接一个IF判断函数用于判出库是否已满（栈是否满），车满判断函数如下：

int parkfull(carpark *P)
    {
        if (P->top == M - 1)
            return 1;
        else
            return 0;
    }
    //车满判断

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8

如果车位没有满，就执行上面入库核心代码else里面的函数直接执行入栈操作。ps：车满是if内的，未满写在了else里面。   
（3）对于库满的操作：   
调用入队操作函数，carroadsaid()，参数明白撒~

/*
    路边等待队列分配
    carroadsaid(int time, int ID, carqueue *L)
    carroadsaid(时间, 车牌, carqueue *L 队列表)
    */
    int carroadsaid(int time, int ID, carqueue *L)
    {
        qptr *T;
        T = (qptr *)malloc(sizeof(qptr));
        if (T == NULL) return 0;//地址分配失败，返回失败
        T->num = outsidenum++;
        T->ID = ID;
        T->arrivetime = time;
        T->next = NULL;
        L->rear->next = T;
        L->rear = T;
        return 1;
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18

--------------------

4、出库运算：

/*
    这里是出库的核心函数
    具体使用如下：
    通过ID（车牌）寻找库内ID（车牌），如果不位于库顶（栈顶），就转移前方车辆至临时路边等待
    出库后，计算停车时间，并将外面临时等待的车重新放入车库
    如果入库后仍有空位，就将外面的等待队列添加进库，直到库满（栈满）
    outparking(int ID, int time, carpark *P, carqueue *L)
    outparking(车牌ID, 出库时间int , carpark *P 库表, carqueue *L 队列表)
    */
    int outparking(int ID, int time, carpark *P, carqueue *L)
    {
        int down = M-1;
        while (down >= 0)
        {
            if (P->stack[down].ID == ID)//找到位置
            {
                if (down == P->top)//车在最外面
                {
                    //这里是车在最外面的code
                    printf("\t\n车牌为%d的，已出库！停车时间：%d，请按标准收费！\n\n", P->stack[down].ID, time - P->stack[down].arrivetime);
                    P->stack[down].ID = P->stack[down].arrivetime = P->stack[down].num = -1;//清空位置
                    --internum;//库内记数减一个
                    --P->top;
                    while (parkfull(P) == 0)//出库后再看有空位没有
                    {
                        //有空位就把等待队列的第一个放进来，且重新输入进入时间
                        //出队操作
                        int _time;
                        qptr *temp;
                        if (L->front == L->rear || L->front->next == NULL) return 0;//队列是空的，直接返回就好
                        temp = L->front->next;
                        P->stack[++P->top].num = internum++;
                        P->stack[P->top].ID = temp->ID;
                        printf("\t\t\n\n车库有空位，请输入队列此车(车牌为：%d)当前入库时间：", temp->ID);
                        scanf("%d", &_time);
                        P->stack[P->top].arrivetime = _time;
                        printf("\n\t此车已在队列中等待：%d time,现已进入车库！\n\n", _time - temp->arrivetime);
                        /*调整队头指针位置，并释放内存空间*/
                        L->front->next = temp->next;
                        if (L->rear == temp) L->rear = temp;//对于队列只剩一个数据时的队头调整
                        outsidenum--;
                        free(temp);
                    }
                    //outqueue(ID, time, P, L);//库空填充函数
                    return 1;
                }
                else 
                {
                    //这里是车不在最外的code
                    //down变量就是当前找到的位置，已经是数组了，不用减1
                    carpark *temp;
                    int x;
                    temp = initstack();//初始化临时停车场
                    P->top = down;//P表的top现在直接调整到找到元素那里
                    for (x=M-1; x >down; x--)
                    {
                        temp->stack[++temp->top].ID = P->stack[x].ID;
                        temp->stack[temp->top].arrivetime = P->stack[x].arrivetime;
                        temp->stack[temp->top].num = P->stack[x].num;
                    }//往临时停车场停车
                    printf("\t\n车牌为%d的，已出库！停车时间：%d，请按标准收费！\n\n", P->stack[down].ID, time - P->stack[down].arrivetime);
                    //P->stack[down].ID = P->stack[down].arrivetime = P->stack[down].num = -1;//清空位置
                    --internum;//库内记数减一个
                    --P->top;//移动top指针
                    while (temp->top >= 0)
                    {
                        if (temp->stack[temp->top].num != -1) //判断是否已经取到原栈高度，也就是不用复制-1值过来，要不然top位置会错位
                        {
                            P->stack[++P->top].ID = temp->stack[temp->top].ID;
                            P->stack[P->top].arrivetime = temp->stack[temp->top].arrivetime;
                            P->stack[P->top].num = temp->stack[temp->top].num;
                            temp->top--;//temp表top位置改变
                            //P->top++;//P表top位置改变
                        }
                        else
                        {
                            break;//顶上是空不再复制过来
                        }
                    }//重新放回车库
                    for (x = P->top+1; x < M; x++)
                        P->stack[x].arrivetime = P->stack[x].ID = P->stack[x].num = -1;//向上清空车库
                    /*
                    这里应该还要判断车库有空位，所以放上面的代码过来
                    要改成单独的函数，要不然太长了
                    不具有独立性
                    ===========================================================================
                    int _num, _time;
                    qptr *temp;
                    if (L->front == L->rear || L->front->next == NULL) return 0;//队列是空的，直接返回就好
                    temp = L->front->next;
                    P->stack[++P->top].num = internum++;
                    P->stack[P->top].ID = temp->ID;
                    printf("\t\t\n\n车库有空位，请输入队列此车(车牌为：%d)当前入库时间：", temp->ID);
                    scanf("%d", &_time);
                    P->stack[P->top].arrivetime = _time;
                    printf("\n\t此车已在队列中等待：%d time,现已进入车库！\n\n", _time - temp->arrivetime);
                    //调整队头指针位置，并释放内存空间
                    L->front->next = temp->next;
                    if (L->rear == temp) L->rear = temp;//对于队列只剩一个数据时的队头调整
                    free(temp);
                    ===========================================================================
                    */
                    //outqueue(ID, time, P, L);//库空填充函数（已弃）
                    while (parkfull(P) == 0)//出库后再看有空位没有
                    {
                        //有空位就把等待队列的第一个放进来，且重新输入进入时间
                        //出队操作
                        int _time;
                        qptr *temp;
                        if (L->front == L->rear || L->front->next == NULL) return 0;//队列是空的，直接返回就好
                        temp = L->front->next;
                        P->stack[++P->top].num = internum++;
                        P->stack[P->top].ID = temp->ID;
                        printf("\t\t\n\n车库有空位，请输入队列此车(车牌为：%d)当前入库时间：", temp->ID);
                        scanf("%d", &_time);
                        P->stack[P->top].arrivetime = _time;
                        printf("\n\t此车已在队列中等待：%d time,现已进入车库！\n\n", _time - temp->arrivetime);
                        /*调整队头指针位置，并释放内存空间*/
                        L->front->next = temp->next;
                        if (L->rear == temp) L->rear = temp;//对于队列只剩一个数据时的队头调整
                        outsidenum--;
                        free(temp);
                    }
                    break;
                }
            }
            down--;//下个比较位置
        }
        return 2;
    }

*  1
 *  2
 *  3
 *  4
 *  5
 *  6
 *  7
 *  8
 *  9
 *  10
 *  11
 *  12
 *  13
 *  14
 *  15
 *  16
 *  17
 *  18
 *  19
 *  20
 *  21
 *  22
 *  23
 *  24
 *  25
 *  26
 *  27
 *  28
 *  29
 *  30
 *  31
 *  32
 *  33
 *  34
 *  35
 *  36
 *  37
 *  38
 *  39
 *  40
 *  41
 *  42
 *  43
 *  44
 *  45
 *  46
 *  47
 *  48
 *  49
 *  50
 *  51
 *  52
 *  53
 *  54
 *  55
 *  56
 *  57
 *  58
 *  59
 *  60
 *  61
 *  62
 *  63
 *  64
 *  65
 *  66
 *  67
 *  68
 *  69
 *  70
 *  71
 *  72
 *  73
 *  74
 *  75
 *  76
 *  77
 *  78
 *  79
 *  80
 *  81
 *  82
 *  83
 *  84
 *  85
 *  86
 *  87
 *  88
 *  89
 *  90
 *  91
 *  92
 *  93
 *  94
 *  95
 *  96
 *  97
 *  98
 *  99
 *  100
 *  101
 *  102
 *  103
 *  104
 *  105
 *  106
 *  107
 *  108
 *  109
 *  110
 *  111
 *  112
 *  113
 *  114
 *  115
 *  116
 *  117
 *  118
 *  119
 *  120
 *  121
 *  122
 *  123
 *  124
 *  125
 *  126
 *  127
 *  128
 *  129
 *  130

# 5、总览： #

--------------------

主函数main.c：

#include <stdio.h>
    #include <stdlib.h>
    #include "mainhead.h"
    main()
    {
        system("color 70");
        char arr;
        char arrtemp;
        int ID,timee;
        carpark *P;//停车场
        carqueue *L;//路边
        /**************初始化**************/
        L= initqueue();
        P = initstack();
        /**************初始化**************/
    
    
        /*
        欢迎信息
        */
        printf("\n\n");
        printf("\t--------        欢迎使用停车场管理系统       ---------\n");
        printf("\t--------Welcome to parking management system!---------\n");
        printf("\n\n");
        do
        {
            printf("格式：入库/出库（A/D），车牌，入库时间/出库时间\t输入T退出，输C查看当前状态！\n请输入：");
            scanf("%c,%d,%d", &arr, &ID, &timee);
            if (arr == 'A' || arr == 'D')
            {
                carinter(arr, ID, timee, P, L);
                arrtemp = getchar();
                fflush(stdin);
            }
            else if (arr == 'T')
            {
                exit(0);
            }
            else  if (arr == 'C')
            {
                arrtemp = getchar();
                fflush(stdin);
                printf("\n\n库内有：%d，库外等待车辆为：%d\n\n", P->top + 1, check());
            }
            else
            {
                system("cls");
                printf("\n\n程序错误的读取了一个字符，导致不能运行，请重新启动！\n\n");
                system("pause");
            }
    
        } while (arr!='\n');
        system("cls");
        printf("\n\n程序错误的读取了一个字符，导致不能运行，请重新启动！\n\n");
        system("pause");
    
    
    
        /*
        2017年4月1日00:02:56
        bug report
        有bug产生，导致错误输出
        循环输出了3遍
        */
        /*
        2017年4月2日14:27:27
        bug
        scanf那里会不明误读，暂时没有解决方案，后序再改
        */
    
    
    
        /*carinter('A', 1, 5, P, L);
        //上面车库已满,入库没问题，开始试库外队列
        carinter('A', 10, 5, P, L);
        carinter('D', 9, 20, P, L);
        system("pause");*/
    }

头文件mainhead.h：

#include <stdio.h>
    #include <stdlib.h>
    #define M 3//车库能停10辆
    static int internum = 0;//总计进入车库的车数辆
    static int outsidenum = 0;//总计还在外面的车辆数
    //-----------------///--------------------///--------------------//
    typedef struct {
        int num;
        int ID;
        int arrivetime;
    }carinformation;
    //定义停车场的结构体
    typedef struct parkinglot {
        carinformation stack[M];
        int top;
    }carpark;
    //-----------------///--------------------///--------------------//
    //--------------------///--------------------///--------------------//
    typedef struct carnode {
        int num;
        int ID;
        int arrivetime;
        //struct node *next;
    }qptr;
    //定义外面狭长路的队列
    typedef struct {
        qptr *front, *rear;
    }carqueue;
    //--------------------///--------------------///--------------------//
    
    carpark *initstack()
    {
        carpark *T;
        T = (carpark *)malloc(sizeof(carpark));
        if (T == NULL)
        {
            /*地址分配错误直接退出程序，不能继续了*/
            system("cls");
            printf("\n\n\t因为内存空间问题，导致程序出错！即将退出！\n\n");
            system("pause");
            exit(0);
        }
        T->top = -1;
        return T;
    }
    //初始化停车场
    carqueue *initqueue()
    {
        carqueue *L;
        L = (carqueue *)malloc(sizeof(carqueue));
        L->front = (carqueue *)malloc(sizeof(carqueue));
        if (L == NULL||L->front == NULL)
        {
            /*地址分配错误直接退出程序，不能继续了*/
            system("cls");
            printf("\n\n\t因为内存空间问题，导致程序出错！即将退出！\n\n");
            system("pause");
            exit(0);
        }
        if (L->front == NULL);
        L->front->next = NULL;
        L->rear = L->front;
        return L;
    }
    //初始化路边停车位
    int parkfull(carpark *P)
    {
        if (P->top == M - 1)
            return 1;
        else
            return 0;
    }
    //车满判断
    
    
    /*
    下面是整个程序的核心内容
    主要实现了进入车库和路边等待的调用
    两个表的地址需要传过来
    车库表和路边队列表；
    carinter(char _array, int num, int time,carpark *P,carqueue *L)
    carinter(进库还是出库char A/D ,车牌号int , 到达时间int ,carpark *P 车库表 ,carqueue *L 路边表)
    */
    int carinter(char _array, int num, int time,carpark *P,carqueue *L)
    {
        if (_array == 'A')
        {
            if (parkfull(P) == 1)
            {
                int temp;
                //这里写车库满后进入队列的code
                printf("\t车牌为：%d的车辆，已进入路边等待！\n\n",num);
                temp = carroadsaid(time, num, L);
                if (temp == 0)
                {
                    /*地址分配错误直接退出程序，不能继续了*/
                    system("cls");
                    printf("\n\n\t因为内存空间问题，导致程序出错！即将退出！\n\n");
                    system("pause");
                    exit(0);
                }
                return 1;
            }
            else
            {
                int _top;
                printf("\t车牌为：%d的车辆，已进入车库！\n\n",num);
                _top = ++P->top;
                P->stack[_top].arrivetime = time;
                P->stack[_top].ID = num;
                P->stack[_top].num = internum++;
                return 1;
            }
        }
        else if (_array == 'D')
        {
            //这里是出库code
            outparking(num, time, P, L);
            return 2;//返回2，不清楚是否成功，只是返回一个数，错误在函数内判断
        }
        else//读取的char是个非法值，所以返回错误
        {
            return 0;
        }
    }
    
    
    /*
    路边等待队列分配
    carroadsaid(int time, int ID, carqueue *L)
    carroadsaid(时间, 车牌, carqueue *L 队列表)
    */
    int carroadsaid(int time, int ID, carqueue *L)
    {
        qptr *T;
        T = (qptr *)malloc(sizeof(qptr));
        if (T == NULL) return 0;//地址分配失败，返回失败
        T->num = outsidenum++;
        T->ID = ID;
        T->arrivetime = time;
        T->next = NULL;
        L->rear->next = T;
        L->rear = T;
        return 1;
    }
    
    
    
    /*
    这里是出库的核心函数
    具体使用如下：
    通过ID（车牌）寻找库内ID（车牌），如果不位于库顶（栈顶），就转移前方车辆至临时路边等待
    出库后，计算停车时间，并将外面临时等待的车重新放入车库
    如果入库后仍有空位，就将外面的等待队列添加进库，直到库满（栈满）
    outparking(int ID, int time, carpark *P, carqueue *L)
    outparking(车牌ID, 出库时间int , carpark *P 库表, carqueue *L 队列表)
    */
    int outparking(int ID, int time, carpark *P, carqueue *L)
    {
        int down = M-1;
        while (down >= 0)
        {
            if (P->stack[down].ID == ID)//找到位置
            {
                if (down == P->top)//车在最外面
                {
                    //这里是车在最外面的code
                    printf("\t\n车牌为%d的，已出库！停车时间：%d，请按标准收费！\n\n", P->stack[down].ID, time - P->stack[down].arrivetime);
                    P->stack[down].ID = P->stack[down].arrivetime = P->stack[down].num = -1;//清空位置
                    --internum;//库内记数减一个
                    --P->top;
                    while (parkfull(P) == 0)//出库后再看有空位没有
                    {
                        //有空位就把等待队列的第一个放进来，且重新输入进入时间
                        //出队操作
                        int _time;
                        qptr *temp;
                        if (L->front == L->rear || L->front->next == NULL) return 0;//队列是空的，直接返回就好
                        temp = L->front->next;
                        P->stack[++P->top].num = internum++;
                        P->stack[P->top].ID = temp->ID;
                        printf("\t\t\n\n车库有空位，请输入队列此车(车牌为：%d)当前入库时间：", temp->ID);
                        scanf("%d", &_time);
                        P->stack[P->top].arrivetime = _time;
                        printf("\n\t此车已在队列中等待：%d time,现已进入车库！\n\n", _time - temp->arrivetime);
                        /*调整队头指针位置，并释放内存空间*/
                        L->front->next = temp->next;
                        if (L->rear == temp) L->rear = temp;//对于队列只剩一个数据时的队头调整
                        outsidenum--;
                        free(temp);
                    }
                    //outqueue(ID, time, P, L);//库空填充函数
                    return 1;
                }
                else 
                {
                    //这里是车不在最外的code
                    //down变量就是当前找到的位置，已经是数组了，不用减1
                    carpark *temp;
                    int x;
                    temp = initstack();//初始化临时停车场
                    P->top = down;//P表的top现在直接调整到找到元素那里
                    for (x=M-1; x >down; x--)
                    {
                        temp->stack[++temp->top].ID = P->stack[x].ID;
                        temp->stack[temp->top].arrivetime = P->stack[x].arrivetime;
                        temp->stack[temp->top].num = P->stack[x].num;
                    }//往临时停车场停车
                    printf("\t\n车牌为%d的，已出库！停车时间：%d，请按标准收费！\n\n", P->stack[down].ID, time - P->stack[down].arrivetime);
                    //P->stack[down].ID = P->stack[down].arrivetime = P->stack[down].num = -1;//清空位置
                    --internum;//库内记数减一个
                    --P->top;//移动top指针
                    while (temp->top >= 0)
                    {
                        if (temp->stack[temp->top].num != -1) //判断是否已经取到原栈高度，也就是不用复制-1值过来，要不然top位置会错位
                        {
                            P->stack[++P->top].ID = temp->stack[temp->top].ID;
                            P->stack[P->top].arrivetime = temp->stack[temp->top].arrivetime;
                            P->stack[P->top].num = temp->stack[temp->top].num;
                            temp->top--;//temp表top位置改变
                            //P->top++;//P表top位置改变
                        }
                        else
                        {
                            break;//顶上是空不再复制过来
                        }
                    }//重新放回车库
                    for (x = P->top+1; x < M; x++)
                        P->stack[x].arrivetime = P->stack[x].ID = P->stack[x].num = -1;//向上清空车库
                    /*
                    这里应该还要判断车库有空位，所以放上面的代码过来
                    要改成单独的函数，要不然太长了
                    不具有独立性
                    ===========================================================================
                    int _num, _time;
                    qptr *temp;
                    if (L->front == L->rear || L->front->next == NULL) return 0;//队列是空的，直接返回就好
                    temp = L->front->next;
                    P->stack[++P->top].num = internum++;
                    P->stack[P->top].ID = temp->ID;
                    printf("\t\t\n\n车库有空位，请输入队列此车(车牌为：%d)当前入库时间：", temp->ID);
                    scanf("%d", &_time);
                    P->stack[P->top].arrivetime = _time;
                    printf("\n\t此车已在队列中等待：%d time,现已进入车库！\n\n", _time - temp->arrivetime);
                    //调整队头指针位置，并释放内存空间
                    L->front->next = temp->next;
                    if (L->rear == temp) L->rear = temp;//对于队列只剩一个数据时的队头调整
                    free(temp);
                    ===========================================================================
                    */
                    //outqueue(ID, time, P, L);//库空填充函数
                    while (parkfull(P) == 0)//出库后再看有空位没有
                    {
                        //有空位就把等待队列的第一个放进来，且重新输入进入时间
                        //出队操作
                        int _time;
                        qptr *temp;
                        if (L->front == L->rear || L->front->next == NULL) return 0;//队列是空的，直接返回就好
                        temp = L->front->next;
                        P->stack[++P->top].num = internum++;
                        P->stack[P->top].ID = temp->ID;
                        printf("\t\t\n\n车库有空位，请输入队列此车(车牌为：%d)当前入库时间：", temp->ID);
                        scanf("%d", &_time);
                        P->stack[P->top].arrivetime = _time;
                        printf("\n\t此车已在队列中等待：%d time,现已进入车库！\n\n", _time - temp->arrivetime);
                        /*调整队头指针位置，并释放内存空间*/
                        L->front->next = temp->next;
                        if (L->rear == temp) L->rear = temp;//对于队列只剩一个数据时的队头调整
                        outsidenum--;
                        free(temp);
                    }
                    break;
                }
            }
            down--;//下个比较位置
        }
        return 2;
    }
    int check()//检查队列数量
    {
        return outsidenum;
    }