数据结构项目二：停车场管理

项目目的：为了深入理解队和栈的使用原理，利用一个栈两个队列简单实现停车场的管理。

Parking.h 文件：


#ifndef __PARKING_H__
#define __PARKING_H__

#define TRUE 1
#define FALSE 0
#define SIZE 20
#define TIME 86400

/*
停车场管理
问题描述：停车场是一个能放n辆车的狭长通道，只有一个大门，
汽车按到达的先后次序停放。若车场满了，车要停在门外的便道上等候，
一旦有车走，则便道上第一辆车进入。当停车场中的车离开时，
由于通道窄，在它后面的车要先退出，待它走后在依次进入。
汽车离开时按停放时间收费。

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

//停放队列
typedef struct park_queue
{
ParkData data[SIZE];
int front; // 指向队头下标
int rear; // 指向队尾下标
}Park_Queue;

// 置空队
int InitPark_Queue (Park_Queue *q);

// 停放队列进队
int EnPark_Queue (Park_Queue *q, ParkData x);

// 停放队列出队
int DePark_Queue (Park_Queue *q, ParkData *x);

// 判停放队列空否
int Park_QueueEmpty (Park_Queue *q);

// 判停放队列满否
int Park_QueueFull (Park_Queue *q);

// 取停放队列队头
int GetFront_Park (Park_Queue *q, ParkData *x);

//让路栈
typedef struct _node
{
ParkData data;
struct _node *next;
}Node;

typedef struct way_stack
{
Node *top;
}Way_Stack;

// 创建让路栈
Way_Stack *Create_Stack();

// 判让路栈空否
int StackEmpty (Way_Stack *s);

// 进让路栈
int Push (Way_Stack *s, ParkData x);

// 出让路栈
int Pop (Way_Stack *s, ParkData *x);

// 获取让路栈顶元素
int GetTop (Way_Stack *s, ParkData *x);

// 销毁让路栈
int Destroy(Way_Stack *s, Park_Queue *q);

//等候队列
typedef struct wait_node
{
ParkData data;
struct wait_node *next; // 指向下一个结点
}Wait_Node;

typedef struct wait_queue
{
Wait_Node *front;
Wait_Node *rear;
}Wait_Queue;

// 候车队
Wait_Queue* Create_Queue();

// 候车队是否为空
int QueueEmpty (Wait_Queue *w);

// 候车队进队
int EnQueue (Wait_Queue *w, ParkData x);

// 候车队出队
int DeQueue (Wait_Queue *w, ParkData *x);

// 停车场情况显示
int Display (Park_Queue *q, Wait_Queue *w);

// 停车休息！
int Park (Park_Queue *q, Wait_Queue *w, ParkData *data);

// 老司机开车了，劳资要出去浪啦！
int Leave (Park_Queue *q, Wait_Queue *w);

// 寻找停车队下标
// tmp 需要出队的 id号， count是要找到元素的队列下标
int FindData(Park_Queue *q, int tmp, int *count);

#endif //__PARKING_H__

Parking.c 文件：

#include "Parking.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

Interface_Display ()
{
system ("clear");
printf ("\t********************************************************\n");
printf ("\t*------------------------------------------------------*\n");
printf ("\t*******    Welcome To Yangzi's Parking Lot！   *********\n");
printf ("\t*                 1、停车                              *\n");
printf ("\t*                 2、离开                              *\n");
printf ("\t*                 3、查看停车场情况                    *\n");
printf ("\t*                 4、退出                              *\n");
printf ("\t*                                                      *\n");
printf ("\t*                                                      *\n");
printf ("\t*                               制作人: 陈阳           *\n");
printf ("\t*                                                      *\n");
printf ("\t*------------------------------------------------------*\n");
printf ("\t********************************************************\n");
}

// 停放队列置空队
int InitPark_Queue (Park_Queue *q)
{
if (q == NULL)
return FALSE;

//置空队
q->front = 0;
q->rear  = 0;

return TRUE;
}

// 停放队列进队
int EnPark_Queue (Park_Queue *q, ParkData x)
{
if (q == NULL)
return FALSE;

if (Park_QueueFull(q))
return FALSE;

q->rear = (q->rear+1) % SIZE;
q->data[q->rear] = x;

return TRUE;
}

// 停放队列出队
int DePark_Queue (Park_Queue *q, ParkData *x)
{
if (q == NULL )
{
return FALSE;
}

if (Park_QueueEmpty(q))
{
return FALSE;
}

q->front = (q->front + 1) % SIZE;
*x = q->data[q->front];

return TRUE;
}

// 判停放队列空否
int Park_QueueEmpty (Park_Queue *q)
{
if (q == NULL)
return FALSE;
return q->front == q->rear;
}

// 判停放队列满否
int Park_QueueFull (Park_Queue *q)
{
if (q == NULL)
return FALSE;

return q->front == (q->rear+1)%SIZE;
}

// 取停放队列队头
int GetFront_Park (Park_Queue *q, ParkData *x)
{
if (q == NULL || x == NULL)
{
return FALSE;
}
if (Park_QueueEmpty (q))
{
return FALSE;
}
int index = (q->front+1)%SIZE;
*x = q->data[index];

return TRUE;
}

// 创建让路栈
Way_Stack *Create_Stack()
{
Way_Stack* s = (Way_Stack*)malloc(sizeof(Way_Stack)/sizeof(char));
if (s == NULL)
return NULL;

// 置空栈
s->top = NULL;

return s;
}

// 让路栈是否为空
int StackEmpty (Way_Stack *s)
{
if (s == NULL)
return FALSE;

return s->top == NULL;
}

// 进入让路栈
int Push (Way_Stack *s, ParkData x)
{
if (s == NULL)
return FALSE;

// 新建结点
Node* node = (Node*)malloc(sizeof(Node)/sizeof(char));
if (node == NULL)
return FALSE;

node->data = x;
node->next = s->top;
s->top = node;

return TRUE;
}

// 出让路栈
int Pop (Way_Stack *s, ParkData *x)
{
if (s == NULL)
return FALSE;

if (StackEmpty(s))
return FALSE;

Node *p = s->top;
*x = p->data;

s->top = p->next;
free(p);

return TRUE;
}

// 获取让路栈顶元素
int GetTop (Way_Stack *s, ParkData *x)
{
if (s == NULL)
return FALSE;

if (StackEmpty(s))
return FALSE;

*x = s->top->data;

return TRUE;
}

// 销毁让路栈并将数据返回停车队
int Destroy(Way_Stack *s, Park_Queue *q)
{
if (s == NULL || q == NULL)
return FALSE;

ParkData x;
while(StackEmpty(s) != TRUE)
{
Pop (s, &x);
EnPark_Queue (q, x);
}

free(s);
return TRUE;
}

// 创建候车队
Wait_Queue* Create_Queue()
{
Wait_Queue *w = (Wait_Queue*)malloc(sizeof(Wait_Queue)/sizeof(char));
if (w == NULL)
return FALSE;

w->front = NULL;
w->rear  = NULL;

return w;
}

// 候车队是否为空
int QueueEmpty (Wait_Queue *w)
{
if (w == NULL)
return FALSE;

return w->front == NULL;
}

// 候车队进队
int EnQueue (Wait_Queue *w, ParkData x)
{
if (w == NULL)
return FALSE;

Wait_Node *node = (Wait_Node*)malloc(sizeof(Wait_Node)/sizeof(char));
if (node == NULL)
return FALSE;

node->data = x;
node->next = NULL;

if (w->front == NULL)
{
w->front = node;
w->re
4000
ar  = node;
}
else
{
w->rear->next = node;
w->rear = node;
}

return TRUE;
}

// 候车队出队
int DeQueue (Wait_Queue *w, ParkData *x)
{
if (w == NULL)
return FALSE;

if (QueueEmpty (w))
return FALSE;

Wait_Node *p = w->front;
*x = p->data;

w->front = p->next;
free(p);

if (w->front == NULL)
w->rear = NULL;

return TRUE;
}

// 停车场情况显示
int Display (Park_Queue *q, Wait_Queue *w)
{
if (q == NULL || w == NULL)
return FALSE;

if (Park_QueueEmpty (q))
{
printf ("停车场为空！\n");
return TRUE;
}

printf ("\t*************************停车列表*************************\n");
ParkData x;
int index = q->front;
do
{	index++;
x = q->data[index%SIZE];
printf ("\t 停车号：%d, 姓名：%s, 车牌号：%s, 停车时间: %d秒 \n ", x.id, x.name, x.number, time(NULL)%TIME - x.parktime);
}while (index != q->rear);

printf ("\t*************************候车列表*************************\n");
if (QueueEmpty (w))
{
printf ("候车队为空\n");
return TRUE;
}
Wait_Node *tmp = w->front; //指向候车队队头
x = tmp->data;
printf ("\t 停车号：%d, 姓名：%s, 车牌号：%s, 候车时间: %d秒\n", x.id, x.name, x.number, time(NULL)%TIME - x.parktime);
while (tmp != w->rear)
{
tmp = tmp->next;
x = tmp->data;
printf ("\t 停车号：%d, 姓名：%s, 车牌号：%s, 候车时间: %d秒\n", x.id, x.name, x.number, time(NULL)%TIME - x.parktime);
};

return TRUE;
}

// 老司机开车了，劳资要出去浪啦！
int Leave (Park_Queue *q, Wait_Queue *w)
{
if (q == NULL || w == NULL)
return FALSE;

if (Park_QueueEmpty (q))
return FALSE;

ParkData x;
int t;

printf ("请输入离开车辆id :");
scanf ("%d", &t);
time_t Time = time(NULL);	//获取当前时间
GetFront_Park (q, &x);		//取停车队队首

//若离开车辆在队头，则直接出队
if (t == x.id)				//x 现在为队首数据
{
DePark_Queue (q, &x);
printf ("离开成功！\n");
printf ("\t现在时间：%s", ctime(&Time));

if (QueueEmpty (w))
{
return TRUE;
}
else	//	候车队队头进停车队
{
DeQueue (w, &x);
x.parktime = time(NULL);	//此时x接收到了候车队抛出的队首数据，并将停车时间初始化
EnPark_Queue (q, x);   			//该数据进入停车队
}
}

//若离开的车辆不在队头，遍历整个停车队列，找到该车
else
{
//创建让路栈
Way_Stack *s = Create_Stack();
if (s == NULL)
{
printf ("让路栈创建失败！\n");
Destroy(s, q);
return FALSE;
}
int count = 0;
if (FindData(q, t, &count) == FALSE)
{
printf ("您输入的id号不在停车场\n");
Destroy(s, q);
return;
}

// 找到id，将该车前面的车放入让车栈，然后离开，再让让车栈的车返回停车队
else
{
int i = 0;
for (i = 0; i < count - 1; i++)
{
DePark_Queue (q, &x);
Push (s, x);
}
DePark_Queue (q, &x);	//该车出停车队
Destroy(s, q);		//销毁让路栈并让让路栈的车回停车队
printf ("离开成功！\n");
printf ("\t现在时间：%s", ctime(&Time));

if (QueueEmpty (w))
{
return TRUE;
}
else
{
DeQueue (w, &x);
x.parktime = time(NULL);
EnPark_Queue (q, x);
}
}
}
return TRUE;
}

// 寻找停车队下标
int FindData(Park_Queue *q, int tmp, int *count)
{
if (q == NULL || count == NULL)
return FALSE;

int flag = 0;
ParkData x;
int index = q->front;
do
{
index++;
(*count)++;
index = index % SIZE;
x = q->data[index];
if (tmp-1 == x.id)
{
flag = 1;
break;
}

}while (index != q->rear);

return flag;
}