tccgl.h

数据结构课程设计,实现一个停车场管理模拟的小程序,主要是对栈和队列的经典操作

	while(p!=NULL)
	{//遍历队列L
		if(p->data.CarNum==temp->CarNum)
			if(p->data.CarKind==temp->CarKind)
				return TRUE;
		p=p->next;
	}//while
	return FALSE;
}//CarInfoCorrStack



//函数名:	CanCarGetInStack
//功能:		判断某一车型的汽车现在是否可以进入栈S
//输入参数:	_CarKind tem_CarKind	"汽车类型"
//返回值:	类型(enum Status)
//			TRUE						"当前车型的汽车可以进入停车场"
//			FALSE						"当前车型的汽车不能进入停车场"
Status CanCarGetInStack(SqStack *S,_CarKind tem_CarKind)
{
	float carsize;
	if(tem_CarKind==A)
		carsize=2;
	else if(tem_CarKind==B)
		carsize=1.5;
	else if(tem_CarKind==C)
		carsize=1;
	else
		return FALSE;
	if(STACK_INIT_SIZE-S->stacksize>=carsize)		//判断剩余空间与汽车占地空间
		return TRUE;
	else
		return FALSE;
}//CanCarGetInStack





//函数名:	InputInfo
//功能:		将tem(CarInfo*)中存储时间的变量初始化为0,避免其它函数处理该数据时出错
//			并且从终端读入如下数据:
//			ArrOrDep(char)	可能值:	A,D,L,E			"进入,离开,显示,退出"
//			tem->CarNum(unsigned int)	全局变量	"车牌号码"
//			tem->CarKind(_CarKind)		全局变量	"车辆类型"	
//			可能改动CurCarSize(float)	全局变量	"存储当前类型汽车能占用空间"
//所需参数:	无
//返回值:	类型(enum Status)
//			TRUE										"得到所需数据"
Status InputInfo(void)
{
	char CarKindKey;					//用来存储汽车类型,
										//将enum中的{A,B,C}用char类型字符表示
	int flag=1;							//辅助循环标志
	tem->ArrTime=(struct tm*)malloc(sizeof(struct tm));				//为到达停车场时刻分配空间
	tem->DepTime=(struct tm*)malloc(sizeof(struct tm));				//为离开停车场时刻分配空间
	tem->ArrTemTime=(struct tm*)malloc(sizeof(struct tm));			//为进入便道时刻分配空间
	tem->DepTemTime=(struct tm*)malloc(sizeof(struct tm));			//为离开便道时刻分配空间
	tem->ArrTime->tm_min=0;											//将到达停车场时刻分钟数置0
	tem->ArrTime->tm_sec=0;											//将到达停车场时刻秒数置0
	tem->DepTime->tm_min=0;											//将离开停车场时刻分钟数置0
	tem->DepTime->tm_sec=0;											//将离开停车场时刻秒数置0
	tem->ArrTemTime->tm_min=0;										//将进入便道时刻分钟数置0
	tem->ArrTemTime->tm_sec=0;										//将进入便道时刻秒数置0
	tem->DepTemTime->tm_min=0;										//将离开便道时刻分钟数置0
	tem->DepTemTime->tm_sec=0;										//将离开便道时刻秒数置0
	//printf("剩余停车位为:%3.1f个\n",STACK_INIT_SIZE-Parking->stacksize);
	do
	{	//若输入数据不为A(进入)或D(离开),则重新输入
		fflush(stdin);
		printf("\r~");
		scanf(" %c,%d, %c",&ArrOrDep,&_tem.CarNum,&CarKindKey);
		//是否退出
		if(ArrOrDep=='E'||ArrOrDep=='e')
			exit(0);
		if(ArrOrDep=='L'||ArrOrDep=='l')
			return TRUE;
		
		if((CarKindKey!='A')&&(CarKindKey!='B')&&(CarKindKey!='C')&&(CarKindKey!='a')&&(CarKindKey!='b')&&(CarKindKey!='c'))
		{	//如果车型输入错误
			printf("您的输入有误,请重新输入!\n");
			flag=2;
			continue;
		}//if
		else
		{	//若车型输入无误,则对车型及其所占空间进行赋值
			if(CarKindKey=='A'||CarKindKey=='a')
			{	//A型车辆
				tem->CarKind=A;				//类型为A
				CurCarSize=2;				//所占空间为2
			}//if
			else if(CarKindKey=='B'||CarKindKey=='b')
			{	//B型车辆
				tem->CarKind=B;				//类型为B
				CurCarSize=1.5;				//所占空间为1.5
			}//else if
			else if(CarKindKey=='C'||CarKindKey=='c')//C型车辆
			{	//C型车辆
				tem->CarKind=C;
				CurCarSize=1;				//所占空间为1
			}//else if
		}//else

		if(ArrOrDep=='D'||ArrOrDep=='d')
			flag=0;							//若要离开
		else if(ArrOrDep=='A'||ArrOrDep=='a')
		{
			flag=0;
		}//else if

		if(flag==1)
		{	//若第一项输入不是A或D
			printf("输入错误!第一项只能为A或D,要退出请输入E,请重新输入!\n");
			continue;
		}//if(fla
		if(tem->CarNum==0)
		{	//若车号为0
			printf("您的输入有误,请重新输入!\n");
			flag=1;
			continue;
		}//if(tem.CarNum
	}while(flag);
	return TRUE;
}//InputInfo




//函数名:	SearchCarFromStack
//功能:		从栈L中查找匹配数据,若找到则返回TRUE,否则返回FALSE
//输入参数:	L(SqStack *)			"要处理的栈"
//			CarNum(unsigned int)	"要匹配的数据"
//返回值:	类型(enum Status)
//			TRUE						"找到匹配数据"
//			FALSE						"未找到匹配数据"
Status SearchCarFromStack(SqStack* L,unsigned int CarNum)
{	//从停车场中查找车号为CarNum的汽车,若找到则返回TRUE,若未找到则返回FALSE
	CarInfo* q;
	q=L->base;
	do
	{
		if(q->CarNum==CarNum)
			return TRUE;
		else
			q++;
	}while(q<L->top);
	return FALSE;
}//SearchCarFromStack


//函数名:	SearchCarFromQueue
//功能:		从队列Q中查找匹配数据,若找到则返回TRUE,否则返回FALSE
//输入参数:	Q(LinkQueue *)			"要处理的栈"
//			CarNum(unsigned int)	"要匹配的数据"
//返回值:	类型(enum Status)
//			TRUE						"找到匹配数据"
//			FALSE						"未找到匹配数据"
Status SearchCarFromQueue(LinkQueue* Q,unsigned int CarNum)
{//从停车场中查找车号为CarNum的汽车,若找到则返回TRUE,若未找到则返回FALSE
	QueuePtr p;
	if(QueueEmpty(Q)==TRUE)
		return FALSE;	//若Q为空队列,返回FALSE
	p=Q->front->next;
	while(p!=NULL)
	{//遍历队列Q
		if(p->data.CarNum==CarNum)
			return TRUE;
		p=p->next;
	}//while
	return FALSE;
}//SearchCarFromQueue

/*
//函数名:	GetCarPosInStack
//功能:		得到当前汽车在停车场中的位置
//输入参数:	S(SqStack* )		"要处理的停车场"
//返回值:	类型(int)
//			Num					"位置号1,2,3..."
int GetCarPosInStack(SqStack *S)
{
	CarInfo* p;
	int Num=1;
	p=S->top-1;
	while(p!=S->base)
	{	//循环至栈底
		Num++;
		p--;
	}//while
	return Num;
}//GetCarPosInStack

//函数名:	GetCarPosInQueue
//功能:		得到当前汽车在便道中的位置
//输入参数:	Q(LinkQueue* )		"要处理的便道"
//返回值:	类型(int)
//			Num					"位置号1,2,3..."
int GetCarPosInQueue(LinkQueue* Q)
{
	QueuePtr p;
	int Num=0;
	p=Q->front->next;
	while(p!=NULL)
	{	//循环至队尾
		Num++;
		p=p->next;
	}//while
	return Num;
}//GetCarPosInQueue

*/
//函数名:	Charge
//功能:		计算当前汽车应交的费用,在便道中产生的费用与在停车场中产生费用之和
//			在屏幕上显示出信息,并返回费用(float)
//输入参数:	ChargingCar(CarInfo* )	"当前汽车信息"
//返回值:	类型(float)				"汽车应交的费用"
float Charge(CarInfo *ChargingCar)
{
	float fee;									//所需要交纳费用
	int duration_stack;							//在停车场停留时间
	int duration_queue;							//在便道中停留时间
	int duration_stack_min;						//停车场中停留分钟数
	int duration_stack_sec;						//停车场中停留秒数
	int duration_queue_min;						//便道中停留分钟数
	int duration_queue_sec;						//便道中停留秒数
	char CarKindKey;							//字符型汽车类型

	//确保费用合法
	if(Fee_Stack_A<0)
		Fee_Stack_A*=-1;
	if(Fee_Stack_B<0)
		Fee_Stack_B*=-1;
	if(Fee_Stack_C<0)
		Fee_Stack_C*=-1;
	if(Fee_Queue_A<0)
		Fee_Queue_A*=-1;
	if(Fee_Queue_B<0)
		Fee_Queue_B*=-1;
	if(Fee_Queue_C<0)
		Fee_Queue_C*=-1;
	//汽车类型转换
	if(ChargingCar->CarKind==A)
		CarKindKey='A';
	else if(ChargingCar->CarKind==B)
		CarKindKey='B';
	else if(ChargingCar->CarKind==C)
		CarKindKey='C';
	//计算停留时间
	duration_queue_min=ChargingCar->DepTemTime->tm_min-ChargingCar->ArrTemTime->tm_min;
	duration_queue_sec=ChargingCar->DepTemTime->tm_sec-ChargingCar->ArrTemTime->tm_sec;
	duration_stack_min=ChargingCar->DepTime->tm_min-ChargingCar->ArrTime->tm_min;
	duration_stack_sec=ChargingCar->DepTime->tm_sec-ChargingCar->ArrTime->tm_sec;
	if(duration_queue_sec<0)
	{	//若便道中停留秒数差值小于0,则分钟数减1,以保证计算正确
		duration_queue_sec=duration_queue_sec+60;
		duration_queue_min--;
	}//if
	if(duration_stack_sec<0)
	{	//若停车场中停留秒数差值小于0,则分钟数减1,以保证计算正确
		duration_stack_sec=duration_stack_sec+60;
		duration_stack_min--;
	}//if
	//将时间全部转换成秒数,以计算费用
	//在本处为秒,在屏幕显示时以分钟除以24的余数做为小时,以秒数做为分钟数
	duration_queue=60*duration_queue_min+duration_queue_sec;
	duration_stack=60*duration_stack_min+duration_stack_sec;

	//开始计算总费用,不同类型的车辆所产生的费用不同
	if(ChargingCar->CarKind==A)				//A型车
		fee=(float)(Fee_Stack_A*duration_stack+Fee_Queue_A*duration_queue);
	else if(ChargingCar->CarKind==B)		//B型车
		fee=(float)(Fee_Stack_B*duration_stack+Fee_Queue_B*duration_queue);
	else									//C型车
		fee=(float)(Fee_Stack_C*duration_stack+Fee_Queue_C*duration_queue);
	if(duration_queue==0)
	{//若该车未在便道中停留
		printf("                  -------------------------------------\n");
		printf("                 |车牌号:            %-d                 |\n",ChargingCar->CarNum);
		printf("                 |车型  :            %c型               |\n",CarKindKey);
		printf("                 |停车场中停留时间:  %2d小时%2d分钟      |\n",duration_stack_min,duration_stack_sec);	
		printf("                 |应交费用:          %5.1f元           |\n",fee);
		printf("                  -------------------------------------\n");
		//printf("您在停车场的停车时间为%d小时%d分钟,所需交纳费用为%.1f元!\n",
			//duration_stack_min,duration_stack_sec,fee);
		return fee;
	}//
	else
	{	//若该车曾在便道中停留
		if(duration_stack==0)
		{	//若该车未在停车场中停留
			printf("                  -------------------------------------\n");
			printf("                 |车牌号:            %-d                 |\n",ChargingCar->CarNum);
			printf("                 |车型  :            %c型               |\n",CarKindKey);
			printf("                 |便道中停留时间:    %2d小时%2d分钟    |\n",duration_queue_min,duration_queue_sec);	
			printf("                 |应交费用:          %5.1f元           |\n",fee);
			printf("                  -------------------------------------\n");
			//printf("您在便道中的停车时间为%d小时%d分钟,所需交纳费用为%.1f元!\n",
				//duration_queue_min,duration_queue_sec,fee);
			return fee;
		}//if(dura
		else
		{	//若该车也在停车场中停留
			printf("                  -------------------------------------\n");
			printf("                 |车牌号:            %-d                |\n",ChargingCar->CarNum);
			printf("                 |车型  :            %c型               |\n",CarKindKey);
			printf("                 |便道中停留时间:    %2d小时%2d分钟      |\n",duration_queue_min,duration_queue_sec);	
			printf("                 |停车场中停留时间:  %2d小时%2d分钟      |\n",duration_stack_min,duration_stack_sec);
			printf("                 |应交费用:          %5.1f元           |\n",fee);
			printf("                  -------------------------------------\n");
			//printf("您在便道中的停车时间为%d小时%d分钟,在停车场的停车时间为%d小时%d分钟,需交纳费用为%.1f元\n",
				//duration_queue_min,duration_queue_sec,duration_stack_min,duration_stack_sec,fee);
			return fee;
		}//else
	}//else
}//Charge


//函数名:	List_Stack
//功能:		刷新屏幕,并将栈S中的信息在屏幕上显示出来
//输入参数:	S(SqStack *)	"要处理的栈"