c语言停车场问题
1. c语言停车场管理问题
细节上的优化就看Lz怎么想了，我觉得提示做得还不够好，免强能用了。
#include
#include
#define N 3 /*停车场大小*/
#define MAX 50 /*过道大小*/
#define sign 10/*车牌大小*/
#define price 10/*每分钟的价钱*/
char part[N][sign];
char Rpart[MAX][sign];
char time[N][20];
int P,R;
partadd(char *t)
{
strcpy(&part[P][0],t);
printf("请输入时间：例如十点十分格式为“10.10”\n");
scanf("%s",&time[P][0]);
getchar();
P++;
}
Rpartadd(char *t)
{
if(R<MAX)
{
strcpy(&Rpart[R][0],t);
R++;
}
else
{
printf("过道己满。无法停车。\n");
}
}
newcar()
{
char temp[sign];
printf("请输入车牌号：");
scanf("%s",temp);
getchar();
if(P<N)
{
partadd(temp);
}
else if(R<MAX)
{
Rpartadd(temp);
}
}
int timed(char *t1,char *t2)
{
int i=0,y=0,x=0,j,n=1;
while(1)
{
if(t1[i]=='.')
{
for(j=i-1;j>=0;j--)
{
y=y+(t1[j]-'0')*(60*n);
n=n*10;
}
while(1)
{
if(t1[j]==NULL)
{
for(n=1;j>i;j--)
{
y=y+(t1[j]-'0')*n;
n=n*10;
}
break;
}
j++;
}
i=0;
while(1)
{
if(t2[i]=='.')
{
for(j=i-1;j>=0;j--)
{
x=x+(t2[j]-'0')*(60*n);
n=n*10;
}
while(1)
{
if(t2[j]==NULL)
{
for(n=1;j>i;j--)
{
x=x+(t2[j]-'0')*n;
n=n*10;
}
break;
}
j++;
}
y=(x-y)*price;
return y;
}
i++;
}
}
i++;
}
}
partcarout(int i)
{
int j,money;
char t[20];
printf("请输入现在的时间：例如十点十分格式为“10.10”\n");
scanf("%s",t);
getchar();
money=timed(t,&time[i][0]);
printf("收费%d\n",money);
for(j=i;j<P;j++)
{
strcpy(&part[j][0],&part[j+1][0]);
P--;
}
if(R!=0)
{
strcpy(&part[N-1][0],&Rpart[0][0]);
P++;
strcpy(&time[P][0],t);
Rpartcarout(0);
}
}
Rpartcarout(int i)
{
int j;
for(j=i;j<R;j++)
{
strcpy(&Rpart[j][0],&Rpart[j+1][0]);
R--;
}
}
carout()
{
char t[sign];
int i,get=0;
printf("请入要离开的车牌号：");
scanf("%s",t);
getchar();
for(i=0;i<P;i++)
{
if(strcmp(t,&part[i][0])==0)
{
get=1;
partcarout(i);
break;
}
}
for(i=0;i<R&&get==0;i++)
{
if(strcmp(t,&Rpart[i][0])==0)
{
get=1;
Rpartcarout(i);
break;
}
}
if(get==0)
{
printf("查无此车。\n");
}
}
jopart()
{
int i;
for(i=0;i<P;i++)
{
printf("%d.%s\n",i,&part[i][0]);
}
}
joRpart()
{
int i;
for(i=0;i<R;i++)
{
printf("%d.%s\n",i,&Rpart[i][0]);
}
}
main()
{
int c;
while(1)
{
printf("请选择要做的事：\n");
printf("1.加入新车。\n");
printf("2.有车离开。\n");
printf("3.显示在停车场内的车。\n");
printf("4.显示在过道上的车。\n");
printf("5.退出。\n");
c=getchar();
getchar();
switch (c)
{
case '1':newcar();
break;
case '2':carout();
break;
case '3':jopart();
break;
case '4':joRpart();
break;
case '5':exit(1);
break;
}
}
}
2. 算法和数据结构 停车场的管理 c语言
C语言数据结构 车队管理
我的结题思路：
车的状态分三种，用switch语句分开{
1：停车 A
库未满，往车库里停车
库满，往便道里停车
2：出车 D
从车库里出车使用临时车库
从变道里出车，使用临时便道
3：停止输入 E
}
注意：
1：请勿略下面代码中 “还没有计算位置” 写的时候提醒自己，上传时我忘删了
2：使用静态数组来记录进去的时间 ，用 a[车牌号]
3：用静态 i 来记录进车库里的进出车
进车 i++
出车 i--
4:在写最关键部分时，我是用到了才定义，所以看着有乱，包含哈-_- -_-
二、关键代码//我用的是VS2013
#include<stdlib.h>
#include<stdio.h>
#include<iostream>
usingnamespacestd;
staticinti=1;
staticinta[100];
#defineSTACK_INITSIZE100
#defineStackIncrement10
#defineOK1
#defineERROR0//结构体..............................................................................
typedefstructGARAGE{//创建车库的结构体
int*base;
int*top;
intstacksize;
intOutTime;
}Garage;
typedefstructTPGarage{//创建临时车库的结构体
int*base;
int*top;
intstacksize;
}TpGarage;
typedefstructQNode{
intdate;
structQNode*next;
}QNode,*QueuePtr;
typedefstruct{//创建便道的结构体
QueuePtrfront;
QueuePtrrear;
}OtGarage;
typedefstructTNode{//创建临时便道的结构体
intTdate;
structTNode*Tnext;
}TNode,*TQueuePtr;
typedefstruct{
TQueuePtrTfront;
TQueuePtrTrear;
}TOtGarage;
//.....................................................机构体..................
//...........................................声明........................
voidInitGarage(Garage&S,intt);//车库
voidPushGarage(Garage&S,intchp,intt);
voidZPushGarage(Garage&S,intchp);
voidGetTopGarage(TOtGarage&TG,OtGarage&OG,TpGarage&T,Garage&S,intchp,intt);
intPop(Garage&S,int&GH);
voidInitTpStack(TpGarage&T);//临时车库
voidPushTpStack(TpGarage&T,intchp);
voidPopTpStack(TpGarage&T,int&chp);
voidInitOtGarage(OtGarage&OG);//变道
voidPushTpStack(TpGarage&T,intchp);
intOutOtGarage(OtGarage&OG,int&e);
voidInitTOtGarage(TOtGarage&TG);//临时便道
voidTEnOtGarage(TOtGarage&TG,int&Te);
intTOutOtGarage(TOtGarage&TG,int&Te);
inttranverse(GarageS,intt);//遍历车库
intPush(charX,intchp,intt,Garage&S,TpGarage&T,OtGarage&OG,TOtGarage&TG);//枢纽
//............................................声明.......................................
//.................................车库........................................................
voidInitGarage(Garage&S,intt){//初始化出库
S.stacksize=t;
S.base=(int*)malloc(S.stacksize*sizeof(int));
S.top=S.base;
}
voidPushGarage(Garage&S,intchp,intt){//车库进车
a[chp]=t;//记录当前的时间
*(S.top)++=chp;
}
voidZPushGarage(Garage&S,intchp){//车库进车
*(S.top)=chp;
S.top++;
}
voidGetTopGarage(TOtGarage&TG,OtGarage&OG,TpGarage&T,Garage&S,intchp,intt){//车库中出
intkeepch=chp;//将当前的车牌保存下来
intgh=0;
intnum;
intfh=0;
inti=0;//记住车库出去车的量
inte=0;//做一个遍历，找出该车的位置
intjs=0;
intTe=0;
S.OutTime=t;//是的话，直接出车，删掉元素
if(tranverse(S,chp)){//做一个遍历，该车在车库的话，就从车库中出车
while(Pop(S,gh)!=keepch){//让车库的车出去
PushTpStack(T,gh);
i++;
}
if(num=(S.OutTime-a[chp])%10==0){
num=S.OutTime-a[chp];
}
elsenum=((S.OutTime-a[chp])/10+1)*10;
cout<<"该车在停车场的时间为"<<num<<//此时输出该车的信息
"分钟，应该收费为"<<0.5*num<<"元"<<endl;
for(size_tj=0;j<i;j++){
PopTpStack(T,fh);//依次将其他开回来，往前挪一位，空出门前的车位
ZPushGarage(S,fh);
}
if(OutOtGarage(OG,e)){//当变道里有车时，从外面再进来一辆车
PushGarage(S,e,S.OutTime);
}
}
else{//注意第一个if,这里是对应的else，表示车要从临时便道里出车
//将便道里的车送到临时便道，
inty=OutOtGarage(OG,gh);
while(gh!=keepch){//让车库的车出去OutOtGarage(OtGarage&OG,int&e)
TEnOtGarage(TG,gh);//推到临时车道
js++;
y=OutOtGarage(OG,gh);
}
if(js==0){//后面的车往前开
//直接从停车场出去
cout<<"该车未在车库停车，无需缴费"<<endl;
}
elseif(!OutOtGarage(OG,e)){//如果此时为底的话，再重新进入变道
for(size_tj=0;j<i;j++){
intv;
v=TOutOtGarage(TG,Te);//
PushTpStack(T,Te);//还没有计算位置
}i--;
cout<<"该车未在车库停车，无需缴费"<<endl;
}
else{
cout<<"该车未在车库停车，无需缴费"<<endl;
intjd;
QueuePtrp;//变道有车的话，返回一个
p=OG.front->next;
e=p->date;
OG.front->next=p->next;
if(OG.rear==p)
OG.rear=OG.front;
free(p);
//先释放一个节点，继续传
while(OutOtGarage(OG,gh)){//让车库的车出去OutOtGarage(OtGarage&OG,int&e)
TEnOtGarage(TG,gh);//推到临时车道
}
while(TOutOtGarage(TG,Te)){
PushTpStack(T,Te);
}i--;
}//如果此时不为底的话，继续进入临时便道，再进入变道
}
}
intPop(Garage&S,int&GH){//车库中出车
GH=*--S.top;
returnGH;
}
//....................................车库.........................
//...............................临时车库..........................
voidInitTpStack(TpGarage&T){//初始化临时车库
T.stacksize=STACK_INITSIZE;
T.base=(int*)malloc(T.stacksize*sizeof(int));
T.top=T.base;
}
voidPushTpStack(TpGarage&T,intchp){
if(T.top-T.base>=T.stacksize){
T.base=(int*)realloc(T.base,
(T.stacksize+STACK_INITSIZE)*sizeof(int));
T.top=T.base+T.stacksize;
T.stacksize+=STACK_INITSIZE;
}
*T.top++=chp;
}
voidPopTpStack(TpGarage&T,int&chp){//当其为返回值为1的时候，删除栈顶且返回
chp=*--T.top;
}
//...........................临时车库.................................
//...........................变道....................................
voidInitOtGarage(OtGarage&OG){//初始化便道
OG.front=OG.rear=(QueuePtr)malloc(sizeof(QNode));
OG.front->next=NULL;
}
voidEnOtGarage(OtGarage&OG,int&e){//进入变道
QueuePtrp;
p=(QueuePtr)malloc(sizeof(QNode));//用来放置车牌号
p->date=e;
p->next=NULL;
OG.rear->next=p;
OG.rear=p;
cout<<"车库已满，该车在变道上的第"<<i<<"位"<<endl;
i++;
cout<<endl;
}
intOutOtGarage(OtGarage&OG,int&e){//变道出车
cout<<endl;//没有车的话，返回0
if(OG.front==OG.rear){
returnERROR;
}
QueuePtrp;//变道有车的话，返回一个
p=OG.front->next;
e=p->date;
OG.front->next=p->next;
if(OG.rear==p)
OG.rear=OG.front;
free(p);
i--;
returnOK;
}
voidInitTOtGarage(TOtGarage&TG){//初始化便道
TG.Tfront=TG.Trear=(TQueuePtr)malloc(sizeof(TNode));
TG.Tfront->Tnext=NULL;
}
voidTEnOtGarage(TOtGarage&TG,int&Te){//进入临时变道
TQueuePtrp;
p=(TQueuePtr)malloc(sizeof(TNode));//用来放置车牌号
p->Tdate=Te;
p->Tnext=NULL;
TG.Trear->Tnext=p;
TG.Trear=p;
//cout<<"车库已满，该车在变道上的第"<<i<<"位"<<endl;
i++;
cout<<endl;
}
intTOutOtGarage(TOtGarage&TG,int&Te){//临时变道出车
cout<<endl;//没有车的话，返回0
if(TG.Tfront==TG.Trear)
returnERROR;
TQueuePtrp;//临时变道有车的话，返回一个
p=TG.Tfront->Tnext;
Te=p->Tdate;
TG.Tfront->Tnext=p->Tnext;
if(TG.Trear==p)
TG.Trear=TG.Tfront;
free(p);
i--;
returnOK;
}
//........................................临时便道...........................
//............................总枢纽...........................................
intPush(charX,intchp,intt,Garage&S,TpGarage&T,OtGarage&OG,TOtGarage&TG){
switch(X){//判断该车是进入还是要离开
case'A':{//情况A，进入车库
if(S.top-S.base>=S.stacksize){
cout<<"时间在第"<<t<<"分钟,"<<"车牌号为"<<chp<<"的小车进入便道等待车位"<<endl;
//车库满，接下来该车进入便道
EnOtGarage(OG,chp);//调用进入变道的函数
}
else{
//cout<<"OOOOO"<<endl;
PushGarage(S,chp,t);//进入车库
}
returnOK;
}break;
case'D':{//情况D，离开车库
GetTopGarage(TG,OG,T,S,chp,t);//1:在车库中的出去
returnOK;
}break;
case'E':{//情况E，所有的车辆弄干净
returnERROR;
}break;
}
}
inttranverse(GarageS,intt){
while(S.top!=S.base){
S.top--;
if(t==*S.top)
returnOK;
}
returnERROR;
}
intmain(){
intnum;
charX;
inttime;
intchp;
intx;
GarageS;
TpGarageT;
OtGarageOG;
TOtGarageTG;
cout<<"温馨提示：本停车场每10分钟收费0.5元，不足10分钟的部分按10分钟收费。"<<endl;
cout<<"请输入停车车位的总数:";
cin>>num;
cout<<endl;
InitGarage(S,num);
InitTpStack(T);
InitOtGarage(OG);
InitTOtGarage(TG);
cout<<"输入停止的标志为(E00)"<<endl;
cout<<"停车信息(格式：（动作，车牌号，时间））："<<endl;do{
cout<<"请输入停车信息"<<endl;
cin>>X>>chp>>time;
x=Push(X,chp,time,S,T,OG,TG);
}while(x);
}
3. 求教：小的停车场问题。 火急，在线等。 C语言的
这题很简单，就说一下思路
每个成员有如下几个元素：
1. uniqueID，可以就简单的从1到n的赋值
2. startTime，由于要按时间计费，所以需要记录起始时间
3. endTime，记录离开时间
定义两个栈，
一个是记录停车场的停车情况，假设为stack1
一个用于记录为了让某一个车离开，而依次退出的排在它前面的车，假设为stack2
车辆入库：直接向stack1压栈
车辆出库：从stack1的栈顶找起，如果uniqueID不是要出库的车，就退栈并压栈到stack2中，再判断stack1的新的栈顶的uniqueID是否为出库的车...直到找到该车或stack1被清空。相关车辆退栈后，将stack2从栈顶开始依次栈并压栈到stack1中
4. 用C语言编写“停车场管理系统”
程序太大 不让发 我是分几次发过去的 打三个出现乱码了 我在重新发一次
/*初始化停车场信息，初始状态为第一层已经停有4辆车,
* 其车位号依次为1—4 , 停车时间依次为20, 15, 10 , 5
*/
void Init(struct Garage gar[][6])
{
int i, j;
/*给所有的车位的层号，车位号初始化，停车时间初始化为0，停车位全都初始化为空*/
for (i=0; i<2; i++)
{
for (j=0; j<6; j++)
{
gar[i][j].lay = i+1;
gar[i][j].garagenum = j+1;
gar[i][j].time = 0;
gar[i][j].isempty = 1;
}
}
/*第一层的1-4号车位停车*/
for (i=0; i<4; i++)
{
gar[0][i].isempty = 0;
}
strcpy(gar[0][0].carnum, "GF8888"); /*我自己初始化的车牌号，你可以自己改一下*/
gar[0][0].time = 20;
strcpy(gar[0][1].carnum, "GF6666");
gar[0][1].time = 15;
strcpy(gar[0][2].carnum, "GF9999");
gar[0][2].time = 10;
strcpy(gar[0][3].carnum, "GF5858");
gar[0][3].time = 5;
}
/*新停入的汽车后，将在此之前的所有车的停车时间加5*/
void AddTime(struct Garage gar[][6])
{
int i, j;
for (i=0; i<2; i++)
{
for (j=0; j<6; j++)
{
if (gar[i][j].isempty == 0)
{
gar[i][j].time += 5;
}
}
}
}
/*停车*/
void Park(struct Garage gar[][6])
{
int i;
char num[8];
printf("请输入车牌号：");
scanf("%s", num);
/*查找空车位*/
for (i=0; i<6; i++)
{
if (gar[0][i].isempty == 1)
{
printf("第一层第%d号车位空着，请在此处停车\n", i+1);
strcpy(gar[0][i].carnum, num);
printf("车牌号：%s 层号：1 车位号： %d \n", num, i+1);
AddTime(gar); /*在此之前停车的所有汽车时间加5*/
gar[0][i].isempty = 0; /*表示该车为已经停车*/
gar[0][i].time = 5; /*将时间设为5*/
return;
}
}
printf("第一层已经没有空车位\n");
for (i=0; i<6; i++)
{
if (gar[1][i].isempty = 1)
{
printf("第二层第%d号车位空着，请在此处停车\n", i+1);
strcpy(gar[1][i].carnum, num);
printf("车牌号：%s 层号：2 车位号： %d \n", num, i+1);
AddTime(gar); /*在此之前停车的所有汽车时间加5*/
gar[1][i].isempty = 0; /*表示该车为已经停车*/
gar[1][i].time = 5; /*将时间设为5*/
return;
}
}
printf("对不起，1 2层都没有空车位，您现在不能在此停车\n");
}
/*查看所有车辆信息*/
void Information(struct Garage gar[][6])
{
int i, j;
printf(" 车牌号 层号 车位号 停车时间\n");
for (i=0; i<2; i++)
{
for(j=0; j<6; j++)
{
if (gar[i][j].isempty == 0)
printf(" %s%8d%8d%8d\n", gar[i][j].carnum, gar[i][j].lay, gar[i][j].garagenum, gar[i][j].time);
}
}
printf("\n");
}
/*取车*/
double Leave(struct Garage gar[2][6])
{
int i, j;
char num[8];
double charge = 0;
printf("请输入要取的车牌号：");
scanf("%s", num);
for (i=0; i<2; i++)
{
for (j=0; j<6; j++)
{
if (!strcmp(gar[i][j].carnum, num))
{
printf("您在%d层%d车位停车%d分钟\n", gar[i][j].lay, gar[i][j].garagenum, gar[i][j].time);
charge = gar[i][j].time/5*0.2;
printf("停车费用为每5分钟0.2元，您需交%.2lf元\n", charge);
gar[i][j].isempty = 1;
return charge;
}
}
}
printf("没有您输入的车号。\n\n");
return charge;
}
/*是否查看总收入*/
void IsPrintTotal(double total)
{
char ch;
printf("是否查看停车收费总计？Y/N");
scanf("%c", &ch);
while (ch!='y' && ch!='Y' && ch!='n' && ch!='N')
{
printf("请输入Y或N ");
scanf("%c", &ch);
printf("\n");
}
switch (ch)
{
case 'Y':
case 'y':
printf("停车收费总计为%.2lf元\n", total);
break;
case 'N':
case 'n':
break;
}
}
main()
{
int choice;
double total = 0;
struct Garage gar[2][6];
Init(gar); //初始化第一层已经停有的4辆车
while (1)
{
Instruction();
printf("请输入要进行的操作:");
scanf("%d", &choice);
while (choice<0 || choice>3)
{
printf("输入的不合法，请输入0-3选择：");
scanf("%d", &choice);
}
switch (choice)
{
case 1:
Park(gar);
break;
case 2:
total += Leave(gar);
IsPrintTotal(total);
break;
case 3:
Information(gar);
break;
case 0:
exit(0);
}
}
return 0;
}
5. C语言栈和队列问题：停车场停车问题
#ifndef__PLOT_H__#define__PLOT_H__#defineFALSE0#defineTRUE1#defineMONEY1//单价可以自己定义#defineMAX_STOP10#defineMAX_PAVE100//存放汽车牌号typedefstruct{
inttime1;//进入停车场时间
inttime2;//离开停车场时间
charplate[10];
//汽车牌照号码，定义一个字符指针类型}Car;//停放栈typedefstruct{
CarStop[MAX_STOP-1];//各汽车信息的存储空间
inttop;//用来指示栈顶位置的静态指针}Stopping;//等候队列typedefstruct{intcount;//用来指示队中的数据个数
CarPave[MAX_PAVE-1];//各汽车信息的存储空间
intfront,rear;//用来指示队头和队尾位置的静态指针}Pavement;//让路栈typedefstruct{
CarHelp[MAX_STOP-1];//各汽车信息的存储空间
inttop;//用来指示栈顶位置的静态指针}Buffer;
Stoppings;
Pavementp;
Bufferb;
Carc;charC[10];voidstop_pave();//车停入便道voidcar_come();//车停入停车位voidstop_to_buff();//车进入让路栈voidcar_leave();//车离开voidwelcome();//主界面函数voidDisplay();//显示车辆信息#
源文件PLot.c
#include"PLot.h"#include<stdio.h>#include<time.h>//包含时间函数的头文件#include<string.h>#include<stdlib.h>voidstop_to_pave()//车停入便道{//判断队满
if(p.count>0&&(p.front==(p.rear+1)%MAX_PAVE))
{printf("便道已满，请下次再来
");
}else
{strcpy(p.Pave[p.rear].plate,C);
p.rear=(p.rear+1)%MAX_PAVE;//队尾指示器加1
p.count++;//计数器加1
printf("牌照为%s的汽车停入便道上的%d的位置
",C,p.rear);
}
}voidcar_come()//车停入停车位{printf("请输入即将停车的车牌号:");//输入车牌号
scanf("%s",&C);if(s.top>=MAX_STOP-1)//如果停车位已满，停入便道
{
stop_to_pave();//停车位->便道函数
}else
{
s.top++;//停车位栈顶指针加1
time_tt1;longintt=time(&t1);//标记进入停车场的时间
char*t2;
t2=ctime(&t1);//获取当前时间
c.time1=t;strcpy(s.Stop[s.top].plate,C);//将车牌号登记
printf("牌照为%s的汽车停入停车位的%d车位,当前时间:%s
",C,s.top+1,t2);
}return;
}voidstop_to_buff()//车进入让路栈{//停车位栈压入临时栈，为需要出栈的车辆让出道
while(s.top>=0)
{
if(0==strcmp(s.Stop[s.top--].plate,C))
{break;
}//让出的车进入让路栈
strcpy(b.Help[b.top++].plate,s.Stop[s.top+1].plate);printf("牌照为%s的汽车暂时退出停车位
",s.Stop[s.top+1].plate);
}
b.top--;//如果停车位中的车都让了道，说明停车位中无车辆需要出行
if(s.top<-1)
{printf("停车位上无此车消息
");
}else
{printf("牌照为%s的汽车从停车场开走
",s.Stop[s.top+1].plate);
}//将让路栈中的车辆信息压入停车位栈
while(b.top>=0)
{strcpy(s.Stop[++s.top].plate,b.Help[b.top--].plate);printf("牌照为%s的汽车停回停车位%d车位
",b.Help[b.top+1].plate,s.top+1);
}//从便道中->停车位
while(s.top<MAX_STOP-1)
{if(0==p.count)//判断队列是否为空
{break;
}//不为空，将便道中优先级高的车停入停车位
else
{strcpy(s.Stop[++s.top].plate,p.Pave[p.front].plate);printf("牌照为%s的汽车从便道中进入停车位的%d车位
",p.Pave[p.front].plate,s.top+1);
p.front=(p.front+1)%MAX_PAVE;
p.count--;
}
}
}voidcar_leave()//车离开{printf("请输入即将离开的车牌号:
");scanf("%s",&C);if(s.top<0)//判断停车位是否有车辆信息
{printf("车位已空，无车辆信息！
");
}else
{
stop_to_buff();
}
time_tt1;
longintt=time(&t1);
c.time2=t;//标记离开停车场的时间
char*t2;
t2=ctime(&t1);//获取当前时间
printf("离开时间%s
需付%ld元
",t2,MONEY*(c.time2-c.time1)/10);
}voidDisplay()
{inti=s.top;if(-1==i)
{printf("停车场为空
");
}
time_tt1;longintt=time(&t1);//标记显示时的时间
printf(" 车牌号 停放时间 当前所需支付金额
");while(i!=-1)
{
printf(" %s %d秒 %d元
",s.Stop[i].plate,t-c.time1,MONEY*(t-c.time1)/10);
i--;
}
}voidwelcome()
{printf(" *******************目前停车场状况***********************
");printf(" 停车场共有%d个车位,当前停车场共有%d辆车,等候区共有%d辆车
",MAX_STOP,s.top+1,(p.rear+MAX_PAVE-p.front)
%MAX_PAVE);printf(" ********************************************************
");printf(" ---------------WelcometoourCarParking---------------
");
printf(" *1.Parking*
");
printf(" *2.leaving*
");
printf(" *3.situation*
");
printf(" *4.exit*
");
printf(" --------------------------------------------------------
");
}
主函数main.c
/**********************************************************
问题描述：停车场是一个能放n辆车的狭长通道，只有一个大门，
汽车按到达的先后次序停放。若车场满了，车要在门外的便道上等候
，一旦有车走，则便道上第一辆车进入。当停车场中的车离开时，由
于通道窄，在它后面的车要先退出，待它走后依次进入。汽车离开
时按停放时间收费。
基本功能要求：
1）建立三个数据结构分别是：停放队列，让路栈，等候队列
2）输入数据模拟管理过程，数据（入或出，车号）。
***********************************************************/#include"PLot.h"intmain()
{//初始化
s.top=-1;
b.top=0;
p.rear=0;
p.count=0;
p.front=0;while(1)
{
system("clear");
welcome();inti,cho;
scanf("%d",&i);if(1==i)car_come();
if(2==i)car_leave();if(3==i)Display();if(4==i)break;
printf("返回请输入1
");
scanf("%d",&cho);if(1==cho)
{continue;
}else
{
printf("您的输入有误，请重新输入
");
scanf("%d",&cho);continue;
}
}return0;
}
6. C语言 停车场管理
很想帮你，但我比较忙，没时间打出来了，给你本书看。
这个题这本书上第62页有。
＜＜数据结构＋算法＞＞
夏克俭编着 国防工业出版
ISBN 7－118－02419－8
高教就有这书
希望对你有帮助
7. 39、停车场管理C语言编程
程序太大 不让发 我是分几次发过去的 打三个出现乱码了 我在重新发一次
/*初始化停车场信息，初始状态为第一层已经停有4辆车,
* 其车位号依次为1—4 , 停车时间依次为20, 15, 10 , 5
*/
void Init(struct Garage gar[][6])
{
int i, j;
/*给所有的车位的层号，车位号初始化，停车时间初始化为0，停车位全都初始化为空*/
for (i=0; i<2; i++)
{
for (j=0; j<6; j++)
{
gar[i][j].lay = i+1;
gar[i][j].garagenum = j+1;
gar[i][j].time = 0;
gar[i][j].isempty = 1;
}
}
/*第一层的1-4号车位停车*/
for (i=0; i<4; i++)
{
gar[0][i].isempty = 0;
}
strcpy(gar[0][0].carnum, "GF8888"); /*我自己初始化的车牌号，你可以自己改一下*/
gar[0][0].time = 20;
strcpy(gar[0][1].carnum, "GF6666");
gar[0][1].time = 15;
strcpy(gar[0][2].carnum, "GF9999");
gar[0][2].time = 10;
strcpy(gar[0][3].carnum, "GF5858");
gar[0][3].time = 5;
}
/*新停入的汽车后，将在此之前的所有车的停车时间加5*/
void AddTime(struct Garage gar[][6])
{
int i, j;
for (i=0; i<2; i++)
{
for (j=0; j<6; j++)
{
if (gar[i][j].isempty == 0)
{
gar[i][j].time += 5;
}
}
}
}
/*停车*/
void Park(struct Garage gar[][6])
{
int i;
char num[8];
printf("请输入车牌号：");
scanf("%s", num);
/*查找空车位*/
for (i=0; i<6; i++)
{
if (gar[0][i].isempty == 1)
{
printf("第一层第%d号车位空着，请在此处停车\n", i+1);
strcpy(gar[0][i].carnum, num);
printf("车牌号：%s 层号：1 车位号： %d \n", num, i+1);
AddTime(gar); /*在此之前停车的所有汽车时间加5*/
gar[0][i].isempty = 0; /*表示该车为已经停车*/
gar[0][i].time = 5; /*将时间设为5*/
return;
}
}
printf("第一层已经没有空车位\n");
for (i=0; i<6; i++)
{
if (gar[1][i].isempty = 1)
{
printf("第二层第%d号车位空着，请在此处停车\n", i+1);
strcpy(gar[1][i].carnum, num);
printf("车牌号：%s 层号：2 车位号： %d \n", num, i+1);
AddTime(gar); /*在此之前停车的所有汽车时间加5*/
gar[1][i].isempty = 0; /*表示该车为已经停车*/
gar[1][i].time = 5; /*将时间设为5*/
return;
}
}
printf("对不起，1 2层都没有空车位，您现在不能在此停车\n");
}
/*查看所有车辆信息*/
void Information(struct Garage gar[][6])
{
int i, j;
printf(" 车牌号 层号 车位号 停车时间\n");
for (i=0; i<2; i++)
{
for(j=0; j<6; j++)
{
if (gar[i][j].isempty == 0)
printf(" %s%8d%8d%8d\n", gar[i][j].carnum, gar[i][j].lay, gar[i][j].garagenum, gar[i][j].time);
}
}
printf("\n");
}
/*取车*/
double Leave(struct Garage gar[2][6])
{
int i, j;
char num[8];
double charge = 0;
printf("请输入要取的车牌号：");
scanf("%s", num);
for (i=0; i<2; i++)
{
for (j=0; j<6; j++)
{
if (!strcmp(gar[i][j].carnum, num))
{
printf("您在%d层%d车位停车%d分钟\n", gar[i][j].lay, gar[i][j].garagenum, gar[i][j].time);
charge = gar[i][j].time/5*0.2;
printf("停车费用为每5分钟0.2元，您需交%.2lf元\n", charge);
gar[i][j].isempty = 1;
return charge;
}
}
}
printf("没有您输入的车号。\n\n");
return charge;
}
/*是否查看总收入*/
void IsPrintTotal(double total)
{
char ch;
printf("是否查看停车收费总计？Y/N");
scanf("%c", &ch);
while (ch!='y' && ch!='Y' && ch!='n' && ch!='N')
{
printf("请输入Y或N ");
scanf("%c", &ch);
printf("\n");
}
switch (ch)
{
case 'Y':
case 'y':
printf("停车收费总计为%.2lf元\n", total);
break;
case 'N':
case 'n':
break;
}
}
main()
{
int choice;
double total = 0;
struct Garage gar[2][6];
Init(gar); //初始化第一层已经停有的4辆车
while (1)
{
Instruction();
printf("请输入要进行的操作:");
scanf("%d", &choice);
while (choice<0 || choice>3)
{
printf("输入的不合法，请输入0-3选择：");
scanf("%d", &choice);
}
switch (choice)
{
case 1:
Park(gar);
break;
case 2:
total += Leave(gar);
IsPrintTotal(total);
break;
case 3:
Information(gar);
break;
case 0:
exit(0);
}
}
return 0;
}
8. 一个c语言题````请大家帮忙
哎.....分太少了,
题目主要是想让你区分和熟悉"队列"和"栈"的概念和操作方法,对于这两种数据结构,要从物理结构(就是内存中的存储)和逻辑结构(该数据结构的特点和定义于该数据结构的操作方法)来理解.题目中停车场里的车是"栈"的数据结构,停车场以外的车是"队列"的数据结构,只需要把操作这两种数据结构的方法应用上来,该题目就解决了.
====================================
其实我也并不是嫌分少,我只是没时间做,我本来不是那么看重分的,很多时候有些问题没分我也在答,你这个问题要做至少四个小时,只有看国庆有没有时间闲着再做了...
9. C语言停车场管理系统
/*----------------------------------------------------------------
// Copyright (C) 2009 沈阳工程学院信息安全工作室
// 版权所有。
//
// 文件名：模拟停车场问题.cpp
// 文件功能描述：模拟停车场问题
//
//
// 创建标识：20091214
//
// 修改标识：20091218
// 修改描述：完成编码
//----------------------------------------------------------------*/
//头文件
#include <iostream>
#include <malloc.h>
#include <string>
#include <windows.h>
//常量定义
#define MAX_STOP 4 //定义停车场最大停车数
#define MAX_PLATE 10 //定义车牌号最大长度
#define TIME_COUNT "秒" //定义时间单位
#define TIME_MS_TO_CONUT 1000 //定义时间进制，意为由TIME_COUNT到毫秒的进制
#define UNIT_PRICE 10 //定义单位时间收费标准
using namespace std; //使用std命名空间
//数据结构定义
//定义存储汽车信息的结构体
typedef struct
{
char license_plate[MAX_PLATE]; //汽车牌照号码，定义为一个字符指针类型
char state; //汽车当前状态，字符p表示停放在停车位上，字符s表示停放在便道上，每辆车的初始状态用字符i来进行表示
int time; //汽车停入停车场时的时间，用来计时收费
}CAR;
//定义模拟停车场的栈结构
typedef struct
{
CAR STOP[MAX_STOP]; //汽车信息的存储空间
int top; //用来指示栈顶位置的静态指针
}SeqStack;
//定义模拟便道的队列结构
typedef struct node
{
CAR WAIT; //汽车信息的存储空间
struct node *next; //用来指示队列位置的动态指针
}QNode; //链队列节点的类型
//定义链队列的收尾指针
typedef struct
{
QNode *front,*rear;
}LQueue; //将头尾指针封装在一起的链队
//函数声明
int Empty_LQueue(LQueue *q); //判队空
int LeaveCheck(SeqStack parking , char *license_plate); //检查离开的车是否在停车场中
int QueueLength(LQueue *q); //判队长度
int Out_LQueue(LQueue *&sidewalk , char *license_plate); //出队操作
int StackEmpty(SeqStack parking); //判断栈是否为空
int StackFull(SeqStack parking); //判断栈是否为满
int StackPop(SeqStack &parking); //出栈操作
int StackTop(SeqStack parking , char *license_plate , int &time);//取栈顶元素
void Car_come(SeqStack &parking , LQueue *&sidewalk); //有车到来时的操作
void Car_leave(SeqStack &parking , LQueue *&sidewalk); //有车离开的操作
void Display(SeqStack parking); //显示停车场内的所有信息 调试时用
void InitStack(SeqStack &parking); //初始化栈
void InitList(LQueue *&sidewalk); //初始化队列
void In_LQueue(LQueue *&sidewalk , char *license_plate); //进队操作
void Input_Check(char *license_plate); ////检验输入的车牌是否合法
void StackPush(SeqStack &parking , char *license_plate , int stop_time);//进栈操作
void main()
{
//定义变量
SeqStack parking;
LQueue *sidewalk = NULL;
char *choice = new char;
int flag = 1; //定义一个变量 判断是否退出
//初始化一个为空的停车场
InitStack(parking);
//初始化一个为空的便道
InitList(sidewalk);
//运行界面及功能选择
while(flag)
{
cout<<"\n\t 停车场模拟管理系统 \n\n";
cout<<"\t|--------------------------------------------------|\n\n";
cout<<"\t|本程序为停车场的模拟管理系统，有车到来时请按C键。|\n\n";
cout<<"\t|然后根据屏幕提示进行相关操作，有车要走时请按l键。|\n\n";
cout<<"\t|然后根据屏幕提示进行相关操作，查看停车场请按D键。|\n\n";
cout<<"\t|然后根据屏幕提示进行相关操作，要退出系统请按Q键。|\n\n";
cout<<"\t|--------------------------------------------------|\n\n";
cout<<"请选择操作：";
gets(choice);
if(1 != strlen(choice))
{
cout<<"请正确输入选项!";
continue;
}
else
{
switch(*choice)
{
case 'c':
case 'C':
{
Car_come(parking,sidewalk);break;
}
case 'l':
case 'L':
{
Car_leave(parking,sidewalk);break;
}
case 'q':
case 'Q':
{
flag=0;break;
}
case 'd':
case 'D':
{
Display(parking);break;
}
default:
cout<<"选择不正确！请重新选择！\n";
}
}
}
}
//有车到来时的操作
void Car_come(SeqStack &parking , LQueue *&sidewalk)
{
//定义变量
char license_plate[MAX_PLATE];
cout<<"请输入车辆的车牌号码：";
Input_Check(license_plate);
//判断停车场是否已满，满则进入便道，不满进入停车场
if(StackFull(parking))
{
In_LQueue(sidewalk , license_plate); //进入便道
cout<<"停车场已满请在便道等候,您的位置为"<<QueueLength(sidewalk)
<<endl;
}
else
{
StackPush(parking , license_plate , GetTickCount()); //进入停车场
cout<<"请进入停车场中的"<<parking.top+1<<"号停车位\n";
}
// Display(parking);
}
//有车离开时的操作
void Car_leave(SeqStack &parking , LQueue *&sidewalk)
{
//定义变量
SeqStack tmpparking; //定义临时停车场
char leave_license_plate[MAX_PLATE]; //要离开的车牌号
char license_plate[MAX_PLATE]; //存放从停车场中读出来的车牌信息
int time;
InitStack(tmpparking); //初始化临时停车场
//判断停车场中是否有车
if(StackEmpty(parking))
{
cout<<"当前停车场中没有车\n";
return; //退出子函数
}
cout<<"请输入要离开的车牌照：";
Input_Check(leave_license_plate);
cout<<"当前停车场中有"<<parking.top+1<<"辆车\n";
if(LeaveCheck(parking , leave_license_plate)) //判断车是否在停车场中
{
//车在停车场中
cout<<"您的车在"<<LeaveCheck(parking , leave_license_plate)<<"号车位上\n";
while(StackTop(parking , license_plate , time)
&& (strcmp(parking.STOP[parking.top].license_plate , leave_license_plate) != 0))
{
strcpy(parking.STOP[parking.top].license_plate , license_plate);
cout<<"牌照为"<<license_plate<<"的车暂时退出停车场"<<parking.top+1<<"号位\n";
StackPush(tmpparking , license_plate , time); //停车场中的车暂时退出 进入临时停车场
StackPop(parking); //出栈
}
cout<<"牌照为"<<license_plate<<"的车离开停车场"<<parking.top+1<<"号位\n";
cout<<"您在停车场中停了"<<(GetTickCount()-time)/TIME_MS_TO_CONUT<<TIME_COUNT<<endl; //输出所停时间信息
cout<<"应缴费用为"<<(GetTickCount()-time)/TIME_MS_TO_CONUT*UNIT_PRICE<<"元\n";; //输出费用信息
StackPop(parking); //出栈
//将临时停车场中的车停回停车场
while(StackEmpty(tmpparking) != 1)
{
StackTop(tmpparking , license_plate , time);
StackPush(parking , license_plate , time);
cout<<"牌照为"<<license_plate<<"的车进入停车场"<<parking.top+1<<"号位\n";
license_plate[0] = '\0';
StackPop(tmpparking);
}
if(parking.top+1 == MAX_STOP-1) //判断车离开前停车场是否停满
if(QueueLength(sidewalk)) //如果停满则判断便道上是否有车
{
//便道中有车 则从便道中停入停车场
Out_LQueue(sidewalk , license_plate); //出队
StackPush(parking , license_plate , GetTickCount()); //入栈
cout<<"在便道中牌照为"<<license_plate<<"的车进入停车场"<<parking.top+1<<"号位\n";
}
}
else
//车不在停车场中
cout<<"您的车不在停车场中！\n";
}
//初始化顺序栈
void InitStack(SeqStack &parking)
{
parking.top = -1;
}
//判栈空
int StackEmpty(SeqStack parking)
{
if(parking.top == -1)
return 1;
else
return 0;
}
//判栈满
int StackFull(SeqStack parking)
{
if(parking.top == MAX_STOP-1)
return 1;
else
return 0;
}
//入栈
void StackPush(SeqStack &parking , char *license_plate , int stop_time)
{
parking.top++;
strcpy(parking.STOP[parking.top].license_plate , license_plate);
parking.STOP[parking.top].state = 'p';
parking.STOP[parking.top].time = stop_time;
}
//出栈 返回栈顶指针
int StackPop(SeqStack &parking)
{
if(StackEmpty(parking))
return 0;
else
return parking.top--;
}
//取栈顶元素
int StackTop(SeqStack parking , char *license_plate , int &time)
{
if(StackEmpty(parking))
return 0;
else
{
strcpy(license_plate , parking.STOP[parking.top].license_plate);
time = parking.STOP[parking.top].time;
return 1;
}
}
//显示所有
void Display(SeqStack parking)
{
if(parking.top == -1)
printf("停车场为空\n");
else
{
while(parking.top != -1)
{
cout<<"车牌号为："<<parking.STOP[parking.top].license_plate;
cout<<"，停在"<<parking.top + 1 <<"号车位上";
cout<<"，已停"<<(GetTickCount()-parking.STOP[parking.top].time)/TIME_MS_TO_CONUT<<TIME_COUNT<<endl;
parking.top--;
}
}
}
//初始化队列
void InitList(LQueue *&sidewalk)
{
sidewalk = (LQueue *)malloc(sizeof(LQueue));
sidewalk->front=sidewalk->rear = NULL;
}
//入队
void In_LQueue(LQueue *&sidewalk,char *license_plate)
{
QNode *car_on_sidewalk;
car_on_sidewalk = (QNode *)malloc(sizeof(QNode)); //为新节点开辟新空间
strcpy(car_on_sidewalk->WAIT.license_plate , license_plate); //将数据写入节点
car_on_sidewalk->WAIT.state = 's'; //写入停车信息
car_on_sidewalk->WAIT.time = GetTickCount(); //写入停车时间
car_on_sidewalk->next = NULL;
if(Empty_LQueue(sidewalk)) //队空则创建第一个节点
sidewalk->front = sidewalk->rear = car_on_sidewalk;
else
{
//队非空插入队尾
sidewalk->rear->next = car_on_sidewalk;
sidewalk->rear = car_on_sidewalk;
}
}
//判队空
int Empty_LQueue(LQueue *q)
{
if(q->front == NULL)
return 1;
else
return 0;
}
//判队长度 返回队长
int QueueLength(LQueue *q)
{
QNode *p=q->front;
int i=0;
while(p != NULL)
{
i++;
p=p->next;
}
return i;
}
//出队 成功返回1 队空返回0
int Out_LQueue(LQueue *&sidewalk,char *license_plate)
{
QNode *car_on_sidewalk;
if(Empty_LQueue(sidewalk)) //如果队空返回0
return 0;
car_on_sidewalk = sidewalk->front;
strcpy(license_plate , car_on_sidewalk->WAIT.license_plate);//取出队头元素
if(sidewalk->front == sidewalk->rear) //队中只有一个元素
sidewalk->front = sidewalk->rear=NULL; //删除元素
else
sidewalk->front = sidewalk->front->next; //队头指针后移
free(car_on_sidewalk); //释放指针
return 1;
}
//检查离开的车是否在停车场中 返回车在停车场中位置 不在则返回0
int LeaveCheck(SeqStack parking,char *license_plate)
{
int flag = parking.top+1; //定义变量记录当前车在停车场中位置
if(StackEmpty(parking))
return 0;
else
{
//查找离开车所在位置
while(parking.top != -1 && strcmp(parking.STOP[parking.top].license_plate , license_plate) != 0)
{
flag--;
parking.top--;
}
return flag;
}
}
//检验输入的车牌是否合法
void Input_Check(char *license_plate)
{
int flag = 1;
int i;
string tmpstr;
while(flag)
{
cin>>tmpstr;
getchar();
if(tmpstr.length()<MAX_PLATE)
{
for(i=0;i<10;i++)
license_plate[i] = tmpstr.c_str()[i];
flag = 0;
}
else
cout<<"输入有误，请重新输入：";
}
}
以前的课设 你看看吧 纯手工的~~