main.c
/* 文件名：main.c 内容:停车场管理系统测试 */
/*头文件的包含*/
#include <stdio.h>
#include <string.h>
#include "Stack.h"
#include "CQueue.h"
#include "park.h"
#include "get.h"
#include <iostream>
using namespace std;
/*测试*/
int main()
{
SqStack P;//停车场
SqStack S;//辅助车道
SqQueue Q;//等待车道
InitStack(P);//初始化
InitStack(S);
InitQueue(Q);
while(1)//无限多个用户（输入）
{
printf("\t-------欢迎来到停车场管理系统！------\n");
printf("\t-------10元/h，请自觉缴费！----------\n");
printf("\t-----------请选择您的操作：----------\n");
printf("\t-------------------------------------\n");
printf("\t* 1:停车 *\n");
printf("\t* 2:取车 *\n");
printf("\t* 3:查询 *\n");
printf("\t* 4:退出 *\n");
printf("\t*************************************\n");
string order;//定义成string类型是为了防止输入字母导致崩溃
cin>>order;
if(order == "1")//停车
{
Showpark(P, Q);
}
else if(order == "2")//取车
{
FindLocate(P, S, Q);
}
else if(order == "3")//查询
{
printf("停车场内共3个车位，目前剩余%d个\n",3 - StackLength(P));
printf("等待车道内共10个车位，目前剩余%d个\n", 10 - QueueLength(Q));
printf("\n");
}
else if(order == "4")//退出
{
printf("您已退出。感谢您的本次使用，期待您的下次使用！\n");
printf("\n");
continue;
}
else//指令输入为其他
{
printf("指令输入有误，请重新输入！\n");
printf("\n");
continue;
}
}
return 0;
}
park.c
/* 文件名：park.c 内容:停车模块的操作 */
#ifndef PARK_C
#define PARK_C
/*头文件的包含*/
#include "park.h"
#include "iostream"
string num;
void JudgeNumP(SqStack &P, SqQueue &Q)//判断用户输入的车牌号是否有效
{
int i;
cin>>num;
int flag = 1;
int m = num.length();//车牌号位数
if(m != 4)
{
flag = 0;
}
else
{
for(i = 0; i < 4; i++)
{
if((num[i] >= 'A' && num[i] <= 'Z')||(num[i] >= 'a' && num[i] <= 'z')||(num[i] >= '0' && num[i] <= '9'))
{
continue;
}
else
{
flag = 0;
break;
}
}
}
if(flag)
{
int cs;//栈重复标记
int cq;//队列重复标记
cs = StackTraverse(P, num);
cq = QueueTraverse(Q, num);
if(cs == -1 && cq == -1)
{
printf("车牌号有效，请进入！\n");
}
else
{
printf("抱歉,此车牌号无效！请输入有效的车牌号。\n");
JudgeNumP(P, Q);//再次进行输入判断，直至输入有效，返回；
}
}
else
{
printf("抱歉,此车牌号无效！请输入有效的车牌号。\n");
JudgeNumP(P, Q);//再次进行输入判断，直至输入有效，返回；
}
}
void Showwait(SqStack &P, SqQueue &Q)//输出等待车道的剩余车辆数。如果有剩余进入等待，如果没有退出。
{
int d = QueueLength(Q);//等待车道内的车辆数
if(d < 10)//假设等待车道最多可以有10辆车等待
{
printf("等待车道共有10个等待车位，现在有%d辆车正在等待。\n", d);
printf("请输入4位车牌号：\n");
JudgeNumP(P, Q);//输入车牌号
EnQueue(Q, num);//进入等待通道
}
else if(d >= 10)//等待车道内已满
{
printf("等待车道共有10个等待车位，现在已有10辆车正在等待。为了防止您的等待时间过长，您已退出!\n");
printf("给您带来的不便，我们深感抱歉。感谢您的本次使用，期待您的下次使用！\n");
}
}
void Showpark(SqStack &P, SqQueue &Q)//输出停车场内剩余车位数。如果有空余输入车牌号进去停车场，如果没有，判断等待通道。
{
int dd = StackLength(P);//停车场内的车辆数
if(dd < 3)//设停车场容量为10,看现在停车场内停的车数
{
printf("停车场内共有3个车位，现在有%d个空余车位。\n", 3 - dd);
printf("请输入您的4位车牌号：\n");
JudgeNumP(P, Q);
Push(P, num);//进入停车场
printf("您已停车完毕！\n");
printf("\n");
}
else if(dd >= 3)
{
printf("停车场内共有3个车位，现在有0个空余车位。\n");
Showwait(P, Q);//判断等待车道是否有空余
}
}
#endif
get.c
/* 文件名：get.c 内容:取车模块的操作 */
#ifndef GET_C
#define GET_C
/*头文件的包含*/
#include "get.h"
#include "iostream"
using namespace std;
double h;//总共停车小时数
string e;
string num1;
void JudgeNumG()//判断用户输入的车牌号是否有效
{
int i;
cin>>num1;
int flag = 1;
int m = num1.length();//车牌号位数
if(m != 4)
{
flag = 0;
}
else
{
for(i = 0; i < 4; i++)
{
if((num1[i] >= 'A' && num1[i] <= 'Z')||(num1[i] >= 'a' && num1[i] <= 'z')||(num1[i] >= '0' && num1[i] <= '9'))
{
continue;
}
else
{
flag = 0;
break;
}
}
}
if(flag)
{
printf("车牌号有效，请稍等！\n");
}
else
{
printf("抱歉,此车牌号无效！请输入有效的车牌号。\n");
JudgeNumG();//再次进行输入判断，直至输入有效，返回；
}
}
void FindLocate(SqStack &P, SqStack &S, SqQueue &Q)//用户取车，查询车在哪里（停车场，等待通道）的哪个位置
{
printf("请输入您的4位车牌号：\n");
JudgeNumG();
if(StackEmpty(P))//停车场内没有车
{
printf("取车失败！停车场内无车！\n");
}
else
{
int Location = QueueTraverse(Q, num1);//用location来存num在等待通道内的位置，如果是-1，则不在等待通道内
if(Location != -1)//如果车在等待通道内
{
GetHead(Q, e);
if(e != num1)//如果不在队头，则不能开走
{
printf("抱歉，取车失败！您的车正在等待通道内，请您耐心等待！\n");
}
else//在队头，可以开走
{
printf("您的车是等待通道内的第一辆，取车成功！\n");
DeQueue(Q, num1);
printf("感谢您的本次使用，期待您的下次使用！\n");
printf("\n");
}
}
else//车“可能”在停车场内
{
int Local = StackTraverse(P, num1);
if(Local != -1)//如果在停车场内
{
for(int i = 0; i < Local - 1; i++)
{
Pop(P, e);
Push(S, e);
}
Pop(P, e);
for(int i = 0; i < Local - 1; i++)//其他车归位
{
Pop(S, e);
Push(P, e);
}
if(!QueueEmpty(Q))
{
DeQueue(Q, e);
Push(P, e);
}
printf("请输入您的停车总时间：");
scanf("%lf", &h);
printf("您的总费用为：%.2lf\n", h * 10);
printf("取车成功。谢谢您的使用，期待您的下次使用！\n");
}
else //都不在
{
printf("抱歉，您输入的车牌号不在我们的停车场和等待通道内。请选择 1:继续取车 or 2:退出？\n");
string order;
cin>>order;
if(order == "1")
{
FindLocate(P, S, Q);
}
else if(order == "2")
{
printf("您已退出。感谢您的本次使用，期待您的下次使用\n");
printf("\n");
}
else
{
printf("指令输入有误，请重新输入！\n");
printf("\n");
}
}
}
}
}
#endif
Stack.c
/*
文件名：Stack.c
内容：基本操作的具体算法操作
*/
#ifndef STACK_C
#define STACK_C
#include "Stack.h"
Status InitStack(SqStack &S)
{
//构造一个空栈
S.base = new SElemType[STACK_INIT_SIZE];
/*if(!S.base)
exit(OVERFLOW);//存储分配失败*/
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
return OK;
}
Status DestroyStack(SqStack &S)
{
//销毁栈S
if(S.base)
delete S.base;
S.base = NULL;
S.top = NULL;
S.stacksize = 0;
return OK;
}
Status ClearStack(SqStack &S)
{
//清空栈
S.top = S.base;
return OK;
}
Status StackEmpty(SqStack S)
{
//判断栈是否为空栈
if(S.base == S.top)
return TRUE;
else
return FALSE;
}
int StackLength(SqStack S)
{
//返回栈的长度
return S.top - S.base;
}
void GetTop(SqStack S, SElemType &e)
{
//取栈顶元素，并赋值给e
/*if(S.base == S.top)
return ERROR;//若空栈，返回ERROR*/
e = *(S.top--);//先移，再取
}
void Push(SqStack &S, SElemType e)
{
//将e元素入栈
/*if(S.top - S.base >= S.stacksize)//栈满，追加存储空间
{
S.base = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT)*sizeof(SElemType));
//if(!S.base)
// exit (OVERFLOW);//存储分配失败
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}*/
*(S.top) = e;//先存，再yi
S.top++;
}
void Pop(SqStack &S, SElemType &e)
{
//弹出栈顶元素，用e返回
/*if(S.base == S.top)
return ERROR;//空栈*/
e = *--S.top;//先移，再取
}
int StackTraverse(SqStack S, string num)
{
int Num = 1, flag = 0;
while(S.top != S.base)
{
if(num == *(S.top-1))
{
flag = 1;
break;
}
Num++;
S.top--;
}
if(flag)
return Num;
else
return -1;
}
#endif
CQueue.c
/* 文件名：CQueue.c 内容：循环队列的算法描述 */
#ifndef CQUEUE_C
#define CQUEUE_C
#include "CQueue.h"
Status InitQueue(SqQueue &Q)
{
Q.base = new QElemType[MAXQSIZE];
/*if(!Q.base) exit (OVERFLOW);//存储分配失败*/
Q.front = Q.rear = 0;
return OK;
}
Status DestroyQueue(SqQueue &Q)
{
if(Q.base)
delete Q.base;
Q.base = NULL;
Q.front = Q.rear = 0;
return OK;
}
Status ClearQueue(SqQueue &Q)
{
Q.rear = Q.front = 0;
return OK;
}
Status QueueEmpty(SqQueue Q)
{
if(Q.front == Q.rear)
return TRUE;
else
return ERROR;
}
int QueueLength(SqQueue Q)
{
return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}
Status EnQueue(SqQueue &Q, QElemType e)
{
if((Q.rear + 1) % MAXQSIZE == Q.front)//队列满
return ERROR;
Q.base[Q.rear] = e;
Q.rear = (Q.rear + 1) % MAXQSIZE;
return OK;
}
Status DeQueue(SqQueue &Q, QElemType &e)
{
if(Q.rear == Q.front)//队列空
return ERROR;
e = Q.base[Q.front];
Q.front = (Q.front + 1) % MAXQSIZE;
return OK;
}
Status GetHead(SqQueue Q, QElemType &e)
{
if(Q.rear == Q.front)//队列空
return ERROR;
e = Q.base[Q.front];
return OK;
}
int QueueTraverse(SqQueue Q, string num)
{
int Location = -1;
while(Q.rear != Q.front)
{
if(num == Q.base[Q.front++])
{
Location = Q.front - 1;
break;
}
}
return Location;
}
#endif
