数据结构课程设计停车场管理系统（数据结构课程设计--用栈建立一个停车场管理系统）

本文目录

• 数据结构课程设计--用栈建立一个停车场管理系统
• 数据结构c语言版的 课程设计
• 数据结构的栈和队列及其应用，设计一个停车场管理系统
• 哪位高手能帮我用C语言(不是C++哦)和数据结构做个停车场管理系统包括实验报告!拜托啦！！！！！！
• 数据结构停车场管理系统

数据结构课程设计--用栈建立一个停车场管理系统

#include《stdio.h》
#include《stdlib.h》
#include《string.h》

#define MAX 20
#define price 0.05

typedef struct time{
int hour;
int min;
}Time;

typedef struct node{
char num;
Time reach;
Time leave;
}CarNode;

typedef struct NODE{
CarNode *stack[MAX+1];
int top;
}SeqStackCar;

typedef struct car{
CarNode *data;
struct car *next;
}QueueNode;

typedef struct Node{
QueueNode *head;
QueueNode *rear;
}LinkQueueCar;

void InitStack(SeqStackCar *);
int InitQueue(LinkQueueCar *);
int Arrival(SeqStackCar *,LinkQueueCar *);
void Leave(SeqStackCar *,SeqStackCar *,LinkQueueCar *);
void List(SeqStackCar,LinkQueueCar);

void main()
{
SeqStackCar Enter,Temp;
LinkQueueCar Wait;
int ch;
InitStack(&Enter);
InitStack(&Temp);
InitQueue(&Wait);
while(1)
{
printf(“\n1. 车辆到达登记“);
printf(“ 2. 车辆离开登记“);
printf(“ 3. 车辆列表显示“);
printf(“ 4. 退出系统\n“);
while(1)
{
scanf(“%d“,&ch);
if(ch》=1&&ch《=4)break;
else printf(“\n请选择： 1~4.“);
}
switch(ch)
{
case 1:Arrival(&Enter,&Wait);break;
case 2:Leave(&Enter,&Temp,&Wait);break;
case 3:List(Enter,Wait);break;
case 4:exit(0);
default: break;
}
}
}

void InitStack(SeqStackCar *s){

int i;
s-》top=0;
for(i=0;i《=MAX;i++)
s-》stack[s-》top]=NULL;
}
int InitQueue(LinkQueueCar *Q){

Q-》head=(QueueNode *)malloc(sizeof(QueueNode));
if(Q-》head!=NULL)
{
Q-》head-》next=NULL;
Q-》rear=Q-》head;
return(1);
}
else return(-1);
}
void PRINT(CarNode *p,int room){

int A1,A2,B1,B2;
printf(“\n车辆离开的时间:“);
scanf(“%d:%d“,&(p-》leave.hour),&(p-》leave.min));
printf(“\n离开车辆的车牌号为:“);
puts(p-》num);
printf(“\n其到达时间为: %d:%d“,p-》reach.hour,p-》reach.min);
printf(“离开时间为: %d:%d“,p-》leave.hour,p-》leave.min);
A1=p-》reach.hour;
A2=p-》reach.min;
B1=p-》leave.hour;
B2=p-》leave.min;
printf(“\n应交费用为: %2.1f元“,((B1-A1)*60+(B2-A2))*price);
free(p);
}
int Arrival(SeqStackCar *Enter,LinkQueueCar *W){

CarNode *p;
QueueNode *t;
p=(CarNode *)malloc(sizeof(CarNode));
flushall();
printf(“\n请输入车牌号(例:豫B1234):“);
gets(p-》num);
if(Enter-》top《MAX)
{
Enter-》top++;
printf(“\n车辆在车场第%d位置.“,Enter-》top);
printf(“\n车辆到达时间:“);
scanf(“%d:%d“,&(p-》reach.hour),&(p-》reach.min));
Enter-》stack[Enter-》top]=p;
return(1);
}
else
{
printf(“\n该车须在便道等待!有车位时进入车场“);
t=(QueueNode *)malloc(sizeof(QueueNode));
t-》data=p;
t-》next=NULL;
W-》rear-》next=t;
W-》rear=t;
return(1);
}
}
void Leave(SeqStackCar *Enter,SeqStackCar *Temp,LinkQueueCar *W)
{
int room;
CarNode *p,*t;
QueueNode *q;

if(Enter-》top》0)
{
while(1)
{
printf(“\n请输入车在车场的位置/1--%d/：“,Enter-》top);
scanf(“%d“,&room);
if(room》=1&&room《=Enter-》top) break;
}
while(Enter-》top》room)
{
Temp-》top++;
Temp-》stack[Temp-》top]=Enter-》stack[Enter-》top];
Enter-》stack[Enter-》top]=NULL;
Enter-》top--;
}
p=Enter-》stack[Enter-》top];
Enter-》stack[Enter-》top]=NULL;
Enter-》top--;
while(Temp-》top》=1)
{
Enter-》top++;
Enter-》stack[Enter-》top]=Temp-》stack[Temp-》top];
Temp-》stack[Temp-》top]=NULL;
Temp-》top--;
}
PRINT(p,room);

if((W-》head!=W-》rear)&&Enter-》top《MAX)
{
q=W-》head-》next;
t=q-》data;
Enter-》top++;
printf(“\n便道的%s号车进入车场第%d位置.“,t-》num,Enter-》top);
printf(“\n请输入%s号车进入车场的时间:“);
scanf(“%d:%d“,&(t-》reach.hour),&(t-》reach.min));
W-》head-》next=q-》next;
if(q==W-》rear) W-》rear=W-》head;
Enter-》stack[Enter-》top]=t;
free(q);
}
else printf(“\n便道里没有车.\n“);
}
else printf(“\n车场里没有车.“);
}
void List1(SeqStackCar *S)
{
int i;
if(S-》top》0)
{
printf(“\n车场:“);
printf(“\n 位置到达时间 车牌号\n“);
for(i=1;i《=S-》top;i++)
{
printf(“ %d “,i);
printf(“ %d:%d “,S-》stack[i]-》reach.hour,S-》stack[i]-》reach.min);
puts(S-》stack[i]-》num);
}
}
else printf(“\n车场里没有车“);
}
void List2(LinkQueueCar *W)
{
QueueNode *p;
p=W-》head-》next;
if(W-》head!=W-》rear)
{
printf(“\n等待车辆的号码为:“);
while(p!=NULL)
{
puts(p-》data-》num);
p=p-》next;
}
}
else printf(“\n便道里没有车.“);
}
void List(SeqStackCar S,LinkQueueCar W)
{
int flag,tag;
flag=1;
while(flag)
{
printf(“\n请选择 1|2|3:“);
printf(“\n1.车场列表\n2.便道列表\n3.返回主菜单\n“);
while(1)
{
scanf(“%d“,&tag);
if(tag》=1||tag《=3) break;
else printf(“\n请选择 1~3:“);
}
switch(tag)
{
case 1:List1(&S);break;
case 2:List2(&W);break;
case 3:flag=0;break;
default: break;
}
}
}

数据结构c语言版的 课程设计

一、问题描述：
利用哈夫曼编码进行信息通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接收端将传来的数据进行译码（复原）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编／译码系统。试为这样的信息收发站写一个哈夫曼码的编／译码系统。

二、基本要求：
1、I：初始化（Initialization），从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件hfmTree中。
2、E：编码（Encoding），利用已建好的哈夫曼树（如不在内存，则从文件hfmTree中读人），对文件ToBeTran中的正文进行编码，然后将结果存入文件CodeFile中。
3、D：译码（Decoding），利用已建好的哈夫曼树将文件CodeFile中的代码进行译码，结果存入文件TextFile中。
4、P：输出代码文件（Print），将文件CodeFile以紧凑格式显示在终端上，每行50个代码。同时将此字符形式的编码文件写入文件CodePrin中。
5、T：输出哈夫曼树（TreePrinting），将已在内存中的哈夫曼树以直观的方式（树或凹人表形式）显示在终端上，同时将此字符形式的哈夫曼树写入文件TreePrint中。

三、测试数据：]
用下表给出的字符集和频度的实际统计数据建立哈夫曼树，并实现以下报文的编码和译码：“THIS PROGRAM IS MY FAVORITE”。

字符 A B C D E F G H I J K L M
频度 186 64 13 22 32 103 21 15 47 1 5 32 20 20

字符 N O P Q R S T U V W X Y Z
频度 57 63 15 1 48 51 80 23 8 18 1 16 1

四、实现提示：
1、哈夫曼编码采用一个字符串数组存储。
2、用户界面可以设计为“菜单”方式：显示上述功能符号，再加上“Q”，表示退出运行Quit。请用户键入一个选择功能符。此功能执行完毕后再显示此菜单，直至某次用户选择了“Q”为止。
3、在程序的一次执行过程中，第一次执行I、D或C命令之后，哈夫曼树已经在内存了，不必再读入。每次执行中不一定执行I命令，因为文件hfmTree可能早已建好。
#include《stdio.h》
#include《string.h》
#include《stdlib.h》
#include《ctype.h》
int n;
struct node{
int w;
int flag;
char c;
struct node *plink,*llink,*rlink;
char code;

}*num,*root;
FILE *fp;
char tmpcode;
int t=0;

void main(void)
{
int i;
void settree(void); //建立树
void code(void); //对文件编码
void decode(void); // 译码
void disp(void);
root=(struct node*)malloc(sizeof(struct node));
puts(“*******************哈夫曼编/译码器演示******************************“);

while(1){
start:

puts(“1. 初始化 2. 编码 3. 译码 4.显示编码表 5. 退出“);
while(scanf(“%d“,&i)!=1)
{
while(getchar()!=’\n’)
continue;
puts(“输入错误!“);
puts(“请重新输入！“);
puts(“1. 初始化 2. 编码 3. 译码 4.显示编码表 5. 退出“);
}
switch (i)
{
case 1:
settree();
break;
case 2:
code();
break;
case 3:
decode();
break;
case 4:
disp();
break;
case 5:
exit(0);
default:
puts(“输入错误！“);
puts(“请重新输入！“);
goto start;
}
}
}
void settree(void)
{
int i,j,k;
struct node *p1,*p2,*tmp,*p;
void go(struct node *);
void setcode(struct node *);//建立每一个字符的编码
void printtree(struct node *);
puts(“输入字符集的大小：“);
scanf(“%d“,&n);
while(getchar()!=’\n’)
continue;

for(i=0;i《n;i++)
{
p=(struct node *)malloc(sizeof(struct node));
puts(“请输入一个字符“);
scanf(“%c“,&p-》c);
while(getchar()!=’\n’)
continue;
puts(“请输入该字符的权值:“);
scanf(“%d“,&p-》w);
while(getchar()!=’\n’)
continue;

p-》plink=NULL;
p-》rlink=NULL;
p-》llink=NULL;
num[i]=p;
}

for(i=0;i《n-1;i++) //（递增）排序
{
for(j=i+1;j《n;j++)
{
if(num[i]-》w》num[j]-》w)
{
tmp=num[i];
num[i]=num[j];
num[j]=tmp;
}
}
}
/*******************************开始建立树***********************/
num[n]=NULL; //结束标志
k=n;
while(num!=NULL)
{
p=(struct node *)malloc(sizeof(struct node));
p1=num;
p2=num;
p-》llink=p1;
p-》rlink=p2;
p-》plink=NULL;
p1-》plink=p;
p2-》plink=p;
p-》w=p1-》w+p2-》w;

for(i=1;i《k;i++)
{
num[i]=num[i+1];
}

k--;
num=p;
for(i=0;i《k-1;i++) //排序
{
for(j=i+1;j《k;j++)
{
if(num[i]-》w》num[j]-》w)
{
tmp=num[i];
num[i]=num[j];
num[j]=tmp;
}
}
}
}

root=num;
/*建立完毕*/
/*写入文件，前序*/
if((fp=fopen(“c:\\hfmtree.wxl“,“wb“))==NULL)
{
puts(“文件打开错误！“);
getchar();
exit(0);
}
setcode(root);
go(root);
fclose(fp);
}
void setcode(struct node *p)
{
if(p-》llink==NULL&&p-》rlink==NULL)
{
tmpcode[t]=’\0’;
strcpy(p-》code,tmpcode);
}
else
{
tmpcode[t++]=’0’;
setcode(p-》llink);
t--;
tmpcode[t++]=’1’;
setcode(p-》rlink);
t--;
}
}

void go(struct node *p)
{

if(p-》llink==NULL&&p-》rlink==NULL)
{
fputc(’(’,fp);
fputc(p-》c,fp);
fputs(p-》code,fp);
fputc(’)’,fp);
}
else
{

go(p-》llink);
go(p-》rlink);
}
}

void code(void)
{
FILE *fp1,*fp2,*fp3;
char ch1,ch2,c;
if((fp1=fopen(“c:\\hfmtree.wxl“,“rb“))==NULL)
{
puts(“文件打开错误！“);
getchar();
exit(0);
}
if((fp2=fopen(“c:\\tobetrans.txt“,“wb“))==NULL)
{
puts(“文件打开错误！“);
getchar();
exit(0);
}
if((fp3=fopen(“c:\\codefile.wxl“,“wb“))==NULL)
{
puts(“文件打开错误！“);
getchar();
exit(0);
}

while((ch1=fgetc(fp2))!=EOF)
{
t=0;

while((ch2=fgetc(fp1))!=EOF)
{
if(ch1==ch2)
{
while((c=fgetc(fp1))!=’)’)
{
tmpcode[t++]=c;
}
tmpcode[t]=’\0’;
fputs(tmpcode,fp3);
fputc(’@’,fp3);
rewind(fp1);
break;
}
}
}
fclose(fp1);
fclose(fp2);
fclose(fp3);
}

void decode(void)
{
FILE *fp1,*fp2,*fp3;
char ch1,ch2,ch3;
char temp_3;
char temp_1;
int t1,t3;
if((fp1=fopen(“c:\\hfmtree.wxl“,“rb“))==NULL)
{
puts(“文件打开错误！“);
getchar();
exit(0);
}
if((fp2=fopen(“c:\\textfile.txt“,“wb“))==NULL)
{
puts(“文件打开错误！“);
getchar();
exit(0);
}
if((fp3=fopen(“c:\\codefile.wxl“,“rb“))==NULL)
{
puts(“文件打开错误！“);
getchar();
exit(0);
}

while((ch3=fgetc(fp3))!=EOF)
{
t3=0;
while(ch3!=’@’)
{
temp_3[t3++]=ch3;
ch3=fgetc(fp3);
}
temp_3[t3]=’\0’;
while((ch1=fgetc(fp1))!=EOF)
{
if(isalpha(ch1))
{
ch2=ch1;
t1=0;
while((ch1=fgetc(fp1))!=’)’)
{
temp_1[t1++]=ch1;
}
temp_1[t1]=’\0’;

if(strcmp(temp_1,temp_3)==0)
{
fputc(ch2,fp2);
rewind(fp1);
break;
}
}
}
}
fclose(fp1);
fclose(fp2);
fclose(fp3);
}

void disp(void)
{
FILE *fp1,*fp2;
char ch1,ch2;
char tmp;
int t;
if((fp1=fopen(“c:\\hfmtree.wxl“,“rb“))==NULL)
{
puts(“文件打开错误！“);
getchar();
exit(0);
}
if((fp2=fopen(“c:\\hfmcode.txt“,“wb“))==NULL)
{
puts(“文件打开错误！“);
getchar();
exit(0);
}
while((ch1=fgetc(fp1))!=EOF)
{
if(ch1==’(’)
{
t=0;
ch1=fgetc(fp1);
ch2=ch1;
while((ch1=fgetc(fp1))!=’)’)
{
tmp[t++]=ch1;
}
tmp[t]=’\0’;
printf(“%c-----%s\n“,ch2,tmp);
fputc(ch2,fp2);
fputc(’-’,fp2);
fputc(’-’,fp2);
fputc(’-’,fp2);
fputs(tmp,fp2);
fputc(’\n’,fp2);
}
}
fclose(fp1);
fclose(fp2);
}

数据结构的栈和队列及其应用，设计一个停车场管理系统

//停车场管理
#include “stdio.h“
#include“stdlib.h“
#include“string.h“
#define OK 1
#define ERROR 0
#define MAX_BUF 20//倒车辅组栈长度
#define MAX_NUM 6//停车场栈长度
#define RATE 5//停车场费率
#define MAXLEN 255//串的最大长度
#define MAX_TEST 100//测试车辆的最大数目
//typedef char SString[MAXLEN];
typedef struct
{//汽车状态，’A’为到达，’D’为离开，’E’为输入结束
char status; //汽车状态
int symbol;//车牌号码
int t;//到达或离去的时间
}DCar;
typedef struct
{//顺序栈
DCar *base,*top;
int stacksize;
}SqStack;
typedef struct QNode
{//队列结点
DCar data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{//链队列
QueuePtr front,rear;
}LinkQueue;
void InitStack(SqStack &S,int size)
{ //构造一个空停车场栈
S.top=S.base=(DCar*)malloc(size*sizeof(DCar));
S.stacksize=size;
}
int Push(SqStack &S,DCar e)
{//栈不满则入栈,否则返回错误
if(S.top-S.base《S.stacksize)
{
*S.top++=e;
return OK;
}
return ERROR;
}
int Pop(SqStack &S,DCar &e)
{//栈非空则执行出栈操作,否则返回错误
if(S.top!=S.base)
{
e=*--S.top;return OK;
}
return ERROR;
}
void InitQueue(LinkQueue &Q)
{//构造一个带头结点的空队列(便道)
Q.front=(QueuePtr)malloc(sizeof(QNode));
Q.front-》next=NULL;
Q.rear =Q.front ;
}
int EnQueue(LinkQueue &Q,DCar e)
{//入队
QueuePtr p;
p=(QueuePtr)malloc(sizeof(QNode));
if(!p)return ERROR;
p-》data=e;p-》next=NULL;
Q.rear-》next =p;Q.rear=p;
return OK;
}
int DeQueue(LinkQueue &Q,DCar &e)
{//出队
QueuePtr p=Q.front-》next ;//p指向队头元素
if(!p)return ERROR;//空队则返回错误
e=p-》data;
Q.front-》next=p-》next;
if(Q.rear==p)Q.rear=Q.front;
free(p);return OK;
}
void DestroyQueue(LinkQueue &Q){ //销毁队列
while(Q.front){
Q.rear=Q.front-》next;
free(Q.front);
Q.front=Q.rear=NULL;
}
}
char Search(SqStack S,LinkQueue Q,int lisence)
{//根据车牌号查找要离开的车是在停车场(栈)还是在便道上(队列)
DCar *p=S.base;//设置栈中的搜索指针
QueuePtr q=Q.front-》next;//链队列中的搜索指针
while(p《S.top){//在栈中搜索
if(p-》symbol==lisence)
return ’S’;//要离开的车在停车场(栈)
p++;
}
while(q){//在队列中搜索
if(q-》data.symbol==lisence)
return ’Q’;//要离开的车在便道上(队列)
q=q-》next;
}
return ’N’;//对应车牌的车没有，输入有误
}
int Charge(float stay)
{//根据停留的时间stay计算费用
//每小时RATE元，超过1小时不足2小时按2小时算，依次内推
return ((int)stay+1)*RATE;
}
int Arrive(SqStack &S,LinkQueue &Q,DCar c)
{//汽车到达处理函数
if(Push(S,c))//进入停车场成功
{
printf(“\n时间%d：%d号车进入停车场\n“,c.t,c.symbol);
return OK;
}
if(EnQueue(Q,c))return OK;//进入便道成功
return ERROR;
//printf(“\nche%d\n“,S.top-S.base);
}
void Depart(SqStack &S,LinkQueue &Q,DCar c)
{//汽车c离开处理函数
char locate;
locate=Search(S,Q,c.symbol);//确定要离开车的位置
SqStack Sbuf;//规避所栈
QueuePtr p;
DCar e;
int stay;
InitStack(Sbuf,MAX_BUF);
switch(locate)
{
case ’S’://汽车c在停车场(栈内)
while((S.top-1)-》symbol!=c.symbol)
{//在汽车c后面进入的车依次倒车
Pop(S,e);//退出停车场
Push(Sbuf,e);//进入规避所
}
Pop(S,e);//汽车c离开
stay=c.t-e.t;//计算停留时间
printf(“\n%d号车离开,停留时间%d,费用：%d“,c.symbol,stay,stay*RATE);
printf(“\n“);
while(Sbuf.base!=Sbuf.top)
{//按原来次序再进入停车场
Pop(Sbuf,e);Push(S,e);
}
if(Q.front!=Q.rear)
{//如果便道上有车(队列非空)则第一辆车进入停车场
DeQueue(Q,e);
e.t=c.t;//开始计时收费
Push(S,e);
printf(“\n%d号车进入停车场,时间：%c\n“,e.t,e.symbol);
}
break;
case ’Q’://汽车c在便道上(队列中)
p=Q.front-》next;//指向队头结点
while(p-》data.symbol==c.symbol)
{//将汽车c前面的车开进规避所
DeQueue(Q,e);Push(Sbuf,e);//进入规避所
p=Q.front-》next;
}
DeQueue(Q,e);//汽车c离开
printf(“\n%d号车未进停车场离开，不收费！“,e.symbol);
printf(“\n“);
while(Sbuf.top!=Sbuf.base)
{//进入规避所的车按原来次序返回到便道上(队列)
Pop(Sbuf,e);
p=(QueuePtr)malloc(sizeof(QNode));
p-》data=e;
p-》next=Q.front-》next;//插入到队头，注意：不是入队操作
Q.front-》next=p;
}
break;
case ’N’:printf(“\n%d车辆信息错误！\n“,c.symbol);break;
}
free(Sbuf.base );
}
int main(){
DCar car[MAX_TEST]={{’A’,1,5},{’A’,2,10},{’D’,1,15},{’A’,3, 20}, {’A’,4,25},{’A’,5,30},{’D’,2,35},{’D’,4,40},{’E’,0,0}};
SqStack S;
LinkQueue Q;
InitStack(S,MAX_NUM);
InitQueue(Q);
for(int i=0;car[i].status!=’E’;i++)
{
if(car[i].status==’A’)Arrive(S,Q,car[i]);
else Depart(S,Q,car[i]);
}
DestroyQueue(Q);
free(S.base);//销毁栈
return 0;
}

哪位高手能帮我用C语言(不是C++哦)和数据结构做个停车场管理系统包括实验报告!拜托啦！！！！！！

把扩展名改成CPP,然后编译连接
///////////////////////////////
下面这个程序是我大二上数据结构课时交的作业,现在正好电脑里面放着,所以就给你,应该满足你老师的要求了.编译环境是 VC++ 6.0
如果不会用的话就在问题补充里说,那个“例“是我临时给你打上去的,随便写了点,你要看不懂例子不会输命令就问我.
/*****************************************************************/

#include 《conio.h》
#include 《malloc.h》
#include 《stdio.h》
#include 《stdlib.h》
#include 《windows.h》

// 清空当前屏幕
#define ClearScreen() system( “cls“ )

// 显示字符串 szPrompt 并等待用户按下任意键
#define Pause( szPrompt ) printf( “%s“, szPrompt ),getch()

typedef struct carinformation // 车辆信息
{
char szRegistrationMark; // 车牌号
char szArrivalTime; // 到达时间
char szEntranceTime; // 进入停车场(开始计费)时间
char szDepartureTime; // 离开时间
} TCARINFORMATION, *LPTCARINFORMATION;

typedef struct carstack
{
LPTCARINFORMATION lpCarInformation; // 车辆信息
int nTop; // 栈顶元素下标
int nStackSize; // 栈容量
} TCARSTACK, *LPTCARSTACK;

// 初始化栈 lpCarStack, 将其容量设置为 nSize
void InitStack( LPTCARSTACK &lpCarStack, int nSize )
{
lpCarStack = ( LPTCARSTACK ) malloc( sizeof ( TCARSTACK ) );
lpCarStack-》lpCarInformation = ( LPTCARINFORMATION ) malloc(
nSize * sizeof ( TCARINFORMATION )
);
lpCarStack-》nTop = -1;
lpCarStack-》nStackSize = nSize;
}

// 车辆信息 carinfo 入栈 lpCarStack
void Push( LPTCARSTACK &lpCarStack, TCARINFORMATION carinfo )
{
lpCarStack-》nTop++;
lpCarStack-》lpCarInformation[lpCarStack-》nTop] = carinfo;
}

// 车辆信息从栈 lpCarStack 中弹出并存入 carinfo
void Pop( LPTCARSTACK &lpCarStack, TCARINFORMATION &carinfo )
{
carinfo = lpCarStack-》lpCarInformation[lpCarStack-》nTop];
lpCarStack-》nTop--;
}

// 若栈 lpCarstack 空,返回 TRUE;否则,返回 FALSE
BOOL IsStackEmpty( LPTCARSTACK lpCarStack )
{
return lpCarStack-》nTop == -1;
}

// 若栈 lpStackFull 满,返回 TRUE;否则,返回 FALSE
BOOL IsStackFull( LPTCARSTACK lpCarStack )
{
return lpCarStack-》nTop == ( lpCarStack-》nStackSize - 1 );
}

// 销毁栈 lpCarStack,将指针 lpCarStack 置为 NULL
void DestroyStack( LPTCARSTACK &lpCarStack )
{
free( lpCarStack-》lpCarInformation );
free( lpCarStack );
lpCarStack = NULL;
}

typedef struct carnode // 链队结点信息
{
TCARINFORMATION carinfo; // 车辆信息
struct carnode *lpNext; // 指向下一个元素的指针
} TCARNODE, *LPTCARNODE;

typedef struct carqueue // 链队
{
LPTCARNODE lpHead; // 头结点
LPTCARNODE lpRear; // 指向当前队尾的指针
int nEffectiveSize; // 当前队中元素个数
} TCARQUEUE, *LPTCARQUEUE;

// 初始化链队 lpCarQueue
void InitQueue( LPTCARQUEUE &lpCarQueue )
{
lpCarQueue = ( LPTCARQUEUE ) malloc( sizeof( TCARQUEUE ) );
lpCarQueue-》lpHead = ( LPTCARNODE) malloc( sizeof( TCARNODE ) );
lpCarQueue-》lpHead-》lpNext = NULL;
lpCarQueue-》lpRear = lpCarQueue-》lpHead;
lpCarQueue-》nEffectiveSize = 0;
}

// 车辆信息 carinfo 入队 lpCarQueue
void EnQueue( LPTCARQUEUE &lpCarQueue, TCARINFORMATION carinfo )
{
LPTCARNODE lpCarNode = ( LPTCARNODE ) malloc( sizeof( carnode ) );
lpCarNode-》carinfo = carinfo;
lpCarNode-》lpNext = NULL;
lpCarQueue-》lpRear-》lpNext = lpCarNode;
lpCarQueue-》lpRear = lpCarQueue-》lpRear-》lpNext;
lpCarQueue-》nEffectiveSize++;
}

// 队头元素从链队 lpCarQueue 中出队并存入 carinfo
void DeQueue( LPTCARQUEUE &lpCarQueue, TCARINFORMATION &carinfo )
{
LPTCARNODE lpTemp = lpCarQueue-》lpHead-》lpNext;
carinfo = lpTemp-》carinfo;
lpCarQueue-》lpHead-》lpNext = lpTemp-》lpNext;
free( lpTemp );
lpCarQueue-》nEffectiveSize--;
}

// 若链队 lpCarQueue 为空,返回 TRUE;否则,返回 FALSE
BOOL IsQueueEmpty( LPTCARQUEUE lpCarQueue )
{
return lpCarQueue-》nEffectiveSize == 0;
}

// 销毁链队 lpCarQueue
void DestroyQueue( LPTCARQUEUE &lpCarQueue )
{
LPTCARNODE lpNextCarNode = NULL;
for ( LPTCARNODE lpCarNode = lpCarQueue-》lpHead; lpCarNode != NULL; lpCarNode = lpNextCarNode )
{
lpNextCarNode = lpCarNode-》lpNext;
free( lpCarNode );
}
free( lpCarQueue );
lpCarQueue = NULL;
}

// 将字符串时间格式转换为数字(分钟)格式,例如 12:36 将被转换为 756 ( 12 * 60 + 36 )
int ConvertTimeFormat( char *lpTime )
{
int nHour = 0;
int nMinute = 0;

sscanf( lpTime, “%d:%d“, &nHour, &nMinute );

return nHour * 60 + nMinute;
}

// 根据在停车场内的停留时间 nContinuanceMinutes (分钟)计算费用
double CalculateExpense( int nContinuanceMinutes )
{
return nContinuanceMinutes * ( 5.0 / 60 );
}

int main( void )
{
int nParkCapability = 0; // 停车场容量

putchar( ’\n’ );
printf( “请输入停车场容量:“ );
scanf( “%d“, &nParkCapability );

LPTCARSTACK lpCarStack = NULL; // 停车场,用栈模拟
InitStack( lpCarStack, nParkCapability );

LPTCARQUEUE lpCarQueue = NULL; // 便道,用链队模拟
InitQueue( lpCarQueue );

char cCommandType = NULL; // 命令类型
char szUserInput = { NULL }; // 用户输入
do
{
ClearScreen();
putchar( ’\n’ );
puts( “--------------------“ );
puts( “[命令类型]“ );
puts( “A - 车辆到达“ );
puts( “D - 车辆离开“ );
puts( “E - 停止输入“ );
puts( “O - 显示当前停车场和便道使用情况“ );
putchar( ’\n’ );
puts( “例:“ );
puts( “A,冀A1234,14:26“ );
puts( “D,冀A1234,16:51“ );
puts( “E“ );
puts( “O“ );
putchar( ’\n’ );
printf( “请输入命令:“ );
scanf( “%s“, szUserInput );
puts( “--------------------“ );

char szCarInformation = { NULL };
sscanf( szUserInput, // 将命令类型与车辆信息分开存放
“%c,%s“,
&cCommandType, // 用户输入的前半部分,即命令类型
szCarInformation // 用户输入的后半部分,即车辆信息
);

char *lpCommaLocation = NULL; // 车辆信息字符串中的逗号位置

for ( lpCommaLocation = szCarInformation; *lpCommaLocation != ’\0’; lpCommaLocation++ )
{
if ( *lpCommaLocation == ’,’ )
{
break;
}
}
*lpCommaLocation = ’\0’;

TCARINFORMATION carinfo = { NULL }; // 存储本次用户输入的车辆信息

strcpy( carinfo.szRegistrationMark, szCarInformation );

if ( cCommandType == ’A’ )
{
strcpy( carinfo.szArrivalTime, lpCommaLocation + 1 );

if ( FALSE == IsStackFull( lpCarStack ) )
{
strcpy( carinfo.szEntranceTime, carinfo.szArrivalTime );
Push( lpCarStack, carinfo );
printf( “已进入停车场第 %d 个车位\n“,
lpCarStack-》nTop + 1
);
printf( “车牌号:\t\t%s\n“, carinfo.szRegistrationMark );
printf( “进入时间:\t%s\n“, carinfo.szEntranceTime );
puts( “是否收费:\t是“ );
}
else
{
EnQueue( lpCarQueue, carinfo );
printf( “停车场已满,已停放在便道的第 %d 个车位\n“,
lpCarQueue-》nEffectiveSize
);
printf( “车牌号:\t\t%s\n“, carinfo.szRegistrationMark );
printf( “停放时间:\t%s\n“, carinfo.szArrivalTime );
puts( “是否收费:\t否“ );
}
}
else if ( cCommandType == ’D’ )
{
strcpy( carinfo.szDepartureTime, lpCommaLocation + 1 );

LPTCARSTACK lpTempCarStack = NULL;
InitStack( lpTempCarStack, nParkCapability );

TCARINFORMATION carinfoOut = { NULL };

BOOL bIsCarFound = FALSE;
while ( FALSE == IsStackEmpty( lpCarStack ) )
{
Pop( lpCarStack, carinfoOut );
if ( 0 != strcmp( carinfoOut.szRegistrationMark, carinfo.szRegistrationMark ) )
{
Push( lpTempCarStack, carinfoOut );
}
else
{
bIsCarFound = TRUE;
break;
}
}

while ( FALSE == IsStackEmpty( lpTempCarStack ) )
{
TCARINFORMATION tempcarinfo = { NULL };
Pop( lpTempCarStack, tempcarinfo );
Push( lpCarStack, tempcarinfo );
}

if ( FALSE == bIsCarFound )
{
printf( “车牌号为 %s 的车未进入停车场.\n“, carinfo.szRegistrationMark );
Pause( “--------------------\n按任意键输入下一条信息...\n“ );
continue;
}

strcpy( carinfoOut.szDepartureTime, carinfo.szDepartureTime );
int nEntranceTime = ConvertTimeFormat( carinfoOut.szEntranceTime );
int nDepartureTime = ConvertTimeFormat( carinfoOut.szDepartureTime );
int nContinuanceMinutes = nDepartureTime - nEntranceTime;
printf( “计费时段:\t%s - %s (共 %d 分钟)\n“,
carinfoOut.szEntranceTime,
carinfoOut.szDepartureTime,
nContinuanceMinutes
);
double rExpense = CalculateExpense( nContinuanceMinutes );
printf( “应交纳的费用:\t%.1lf 元\n“, rExpense );

if ( FALSE == IsQueueEmpty( lpCarQueue ) )
{
TCARINFORMATION tempcarinfo = { NULL };
DeQueue( lpCarQueue, tempcarinfo );
strcpy( tempcarinfo.szEntranceTime, carinfoOut.szDepartureTime );
Push( lpCarStack, tempcarinfo );
puts( “--------------------“ );
printf( “停放在便道的第 1 个车位,车牌号为 %s 的车已进入停车场\n“,
tempcarinfo.szRegistrationMark
);
}
}
else if ( cCommandType == ’E’ )
{
puts( “********************“ );
puts( “陈赛 - Build20090507\n“ );
puts( “********************“ );
break;
}
else if ( cCommandType == ’O’ )
{
ClearScreen();
putchar( ’\n’ );
puts( “[停车场使用情况]\n“ );
puts( “[车位]\t[车牌号]\t[到达时间]\t[进入(开始计费)时间]\n“);
for ( int i = 0; i 《= lpCarStack-》nTop; i++ )
{
printf( “%d\t%s\t\t%s\t\t%s\n“,
i + 1,
lpCarStack-》lpCarInformation[i].szRegistrationMark,
lpCarStack-》lpCarInformation[i].szArrivalTime,
lpCarStack-》lpCarInformation[i].szEntranceTime
);
}
putchar( ’\n’ );
putchar( ’\n’ );
putchar( ’\n’ );
puts( “[便道使用情况]\n“ );
puts( “[车位]\t[车牌号]\t[到达时间]\t[进入(开始计费)时间]\n“);
int nNum = 0;
for ( LPTCARNODE lpCarNode = lpCarQueue-》lpHead-》lpNext;
lpCarNode != NULL; lpCarNode = lpCarNode-》lpNext )
{
nNum++;
printf( “%d\t%s\t\t%s\t\t%s\n“,
nNum,
lpCarNode-》carinfo.szRegistrationMark,
lpCarNode-》carinfo.szArrivalTime,
lpCarNode-》carinfo.szEntranceTime
);
}
putchar( ’\n’ );
}
else
{
puts( “输入信息有误.第一个字符只能为 ’A’ 或 ’D’ 或 ’E’ 或 ’O’ (区分大小写).“ );
}
Pause( “--------------------\n按任意键输入下一条信息.\n“ );
} while ( TRUE );

DestroyStack( lpCarStack );
DestroyQueue( lpCarQueue );

Pause( “\n按任意键退出程序...\n“ );

return 0;
}

数据结构停车场管理系统

#include《iostream》
#include《string》
using namespace std;
#define MAX 2 //停车场车位数
#define price 0.05 //每分钟收取的费用
typedef struct time
{
int hour;
int min;
}Time;//定义时间结点
typedef struct node
{
string num;
Time reach;
Time leave;
}CarNode;//定义每辆车的牌号，进入时刻，开出时刻
typedef struct NODE
{
CarNode *stack[MAX+1];
int top;
}SeqStackCar;//用栈定义，构造停车场
typedef struct car
{
CarNode *data;
struct car *next;
}QueueNode;//用队列结点定义，构造停车场外的单个等候车辆
typedef struct Node
{
QueueNode *head;
QueueNode *rear;
}LinkQueueCar;//用队列定义，构造停车场外的等候便道

void InitStack(SeqStackCar *); //初始化堆栈函数声明
int InitQueue(LinkQueueCar *); //初始化队列头结点函数声明
int Arrival(SeqStackCar *,LinkQueueCar *); //车辆进入时登记函数声明
void Leave(SeqStackCar *,SeqStackCar *,LinkQueueCar *);//车辆离开时函数声明
void List(SeqStackCar,LinkQueueCar); /*查看停车场内车辆情况及
便道上车辆情况的函数声明*/
void main( )
{
SeqStackCar Enter,Temp;//初始栈，中转栈
LinkQueueCar Wait;//便道队列
int a;
InitStack(&Enter);
InitStack(&Temp);
InitQueue(&Wait);//初始化
while(1)
{
cout《《“********************************************************************“《《endl;
cout《《“ 欢迎光临停车场！“;
cout《《“(*^__^*) ！“;
cout《《endl《《“车辆到达登记-》请按 1“;
cout《《“ 车辆离开登记-》请按 2“《《endl;
cout《《“车辆停靠查询-》请按 3“;
cout《《“ 退出系统-》请按 4“《《endl;//系统选项设置
while(1)
{
cin》》a;
if(a》=1&&a《=4) break;
else cout《《endl《《“请选择： 1~4.“;
}
switch(a)
{
case 1:Arrival(&Enter,&Wait);break;//调用入停车场函数
case 2:Leave(&Enter,&Temp,&Wait);break;//调用出停车场函数
case 3:List(Enter,Wait);break;//调用查看函数
case 4:exit(0);
default: break;
}
}
}
void InitStack(SeqStackCar *s) //堆栈初始化
{
s-》top=0;
s-》stack[s-》top]=NULL;
}
int InitQueue(LinkQueueCar *Q)//队列初始化
{
Q-》head=new QueueNode ;
if(Q-》head!=NULL)
{
Q-》head-》next=NULL;
Q-》rear=Q-》head;
return 1;
}
else return -1;
}
void PRINT(CarNode *p,int room) //输出离开停车场的车辆情况
{
int A,B,C,D;
cout《《“\n车辆离开的时间:“;
cin》》p-》leave.hour》》p-》leave.min;
cout《《“离开车辆的车牌号为:“;
cout《《p-》num;
cout《《endl《《“其到达时间为: “《《p-》reach.hour《《“:“《《p-》reach.min;
cout《《“离开时间为: “《《p-》leave.hour《《“:“《《p-》leave.min;
A=p-》reach.hour;
B=p-》reach.min;
C=p-》leave.hour;
D=p-》leave.min;
cout《《endl《《“应交费用为: “《《((C-A)*60+(D-B))*price《《“元“《《endl;
cout《《“车辆离开登记完毕!“《《endl;
cout《《“*********************************************************************“《《endl;
delete p;
}
int Arrival(SeqStackCar *Enter,LinkQueueCar *W)
{
CarNode *p;
QueueNode *t;
p=new CarNode;
cout《《“********************************************************************“《《endl;
cout《《“车辆到达登记开始：“《《endl;
cout《《endl《《“请输入车牌号:“;
cin》》p-》num;
if(Enter-》top《MAX)//如果车位未满则进停车场内
{
Enter-》top++;
cout《《endl《《“车辆在车场第“《《Enter-》top《《“位置.“;
cout《《endl《《“车辆到达时间:“;
cin》》p-》reach.hour》》p-》reach.min;
cout《《endl《《“车辆到达登记完毕!“《《endl;
cout《《“*********************************************************************“《《endl;
Enter-》stack[Enter-》top]=p;
return 1;
}
else //如果车位已满，则停靠在便道上
{
cout《《“*********************************************************************“《《endl;
cout《《endl《《“该车须在便道等待!有车位时进入车场“《《endl;
t=new QueueNode ;
t-》data=p;
t-》next=NULL;
W-》rear-》next=t;
W-》rear=t;
return 1;
}
}
void Leave(SeqStackCar *Enter,SeqStackCar *Temp,LinkQueueCar *W)
{
int room;
CarNode *p,*t;
QueueNode *q;

if(Enter-》top》0)
{
while(1)
{
cout《《“*********************************************************************“《《endl;
cout《《“车辆离开登记开始:“《《endl;
cout《《endl《《“请输入车在车场的位置/1--“《《Enter-》top《《“/:“;
cin》》room;
if(room》=1&&room《=Enter-》top) break;
}
while(Enter-》top》room)//从停车场堆栈向中转堆栈移动车辆，直到要离开车辆的位置停止
{
Temp-》top++;
Temp-》stack[Temp-》top]=Enter-》stack[Enter-》top];
Enter-》stack[Enter-》top]=NULL;
Enter-》top--;
}
p=Enter-》stack[Enter-》top];
Enter-》stack[Enter-》top]=NULL;
Enter-》top--;
while(Temp-》top》=1)//将中转堆栈中的车辆移回停车场堆栈
{
Enter-》top++;
Enter-》stack[Enter-》top]=Temp-》stack[Temp-》top];
Temp-》stack[Temp-》top]=NULL;
Temp-》top--;
}
cout《《“*********************************************************************“《《endl;
cout《《“车辆离开登记结算：“《《endl;
PRINT(p,room);
if((W-》head!=W-》rear)&&Enter-》top《MAX)
{
q=W-》head-》next;
t=q-》data;
Enter-》top++;
cout《《endl《《“便道的“《《t-》num《《“号车进入车场第“;
cout《《Enter-》top《《“位置.“《《endl;
cout《《“请输入“《《t-》num《《“号车进入车场的时间:“;
cin》》t-》reach.hour》》t-》reach.min;
W-》head-》next=q-》next;
if(q==W-》rear) W-》rear=W-》head;
Enter-》stack[Enter-》top]=t;
delete q;
}
else cout《《endl《《“便道里没有车“《《endl;
}
else cout《《endl《《“车场里没有车.“《《endl;
}
void List1(SeqStackCar *S) //查看停车场内车辆情况的函数定义
{
int i;
if(S-》top》0)
{
cout《《“********************************************************************“《《endl;
cout《《endl《《“车场内部车辆停靠情况:“《《endl;
cout《《endl《《“位置 到达时间 车牌号“《《endl;
for(i=1;i《=S-》top;i++)
{
cout《《i;
cout《《“ “《《S-》stack[i]-》reach.hour《《“:“《《S-》stack[i]-》reach.min;
cout《《“ “《《S-》stack[i]-》num《《endl;
}
}
else cout《《endl《《“车场里没有车“《《endl;
cout《《“********************************************************************“《《endl;
}
void List2(LinkQueueCar *W) //查看便道上停靠车辆情况的函数定义
{
QueueNode *p;
p=W-》head-》next;
if(W-》head!=W-》rear)
{
cout《《“********************************************************************“《《endl;
cout《《endl《《“便道停靠车辆情况:“《《endl;
while(p!=NULL)
{
cout《《endl《《“车辆牌号：“;
cout《《p-》data-》num《《endl;
p=p-》next;
}
}
else cout《《endl《《“便道里没有车.“《《endl;
cout《《“********************************************************************“《《endl;
}
void List(SeqStackCar S,LinkQueueCar W) //车辆列表显示函数
{
int flag,tag;
flag=1;
while(flag)
{
cout《《“********************************************************************“《《endl;
cout《《“车辆停靠查询开始：“《《endl;
cout《《endl《《“请选择 1|2|3:“《《endl;
cout《《“1.车场列表“《《endl《《“2.便道列表“《《endl《《“3.返回主菜单“《《endl;
while(1)
{
cin》》tag;
if(tag》=1||tag《=3) break;
else cout《《endl;
cout《《“请选择 1~3:“;
}
switch(tag)
{
case 1:List1(&S);
cout《《“车辆停靠查询结束!“《《endl;break;
case 2:List2(&W);
cout《《“车辆停靠查询结束!“《《endl;break;
case 3:flag=0;break;
default: break;
}
}
cout《《“********************************************************************“《《endl;
}