数据结构实验——C语言实现停车场管理系统模拟，锻炼栈、队列的使用

快来打我* 2023-03-14 10:51 18阅读 0赞

#include <time.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #define MAXNUM 5 // 停车场车位数
    #define PRICE 2.0 // 停车场收费标准
    // 定义车
    typedef struct { 
    	char num[12];		// 车牌号,最长10位
    	struct tm intime;	// 进入时间
    	struct tm outtime;	// 离开时间
    	int expense;		// 费用 
    	int length;			// 停车时长
    	int position;		// 停车位
    }CAR;
    
    // 定义栈
    typedef struct { 
    	CAR car[MAXNUM];
    	int top;
    }Stack;
    
    // 定义链队列的结点
    typedef struct carnode{ 
    	CAR data;
    	struct carnode *next;
    }CarNode;
    
    // 定义队列 
    typedef struct { 
    	CarNode *head;
    	CarNode *rear;
    }CarChainQueue;
    
    
    // 初始化栈
    void StackInit(Stack *s) { 
    	s->top = -1;
    }
    
    int StackIsEmpty(Stack *s) { 
    	if (s->top == -1) { 
    		return 1;
    	}
    	else
    	{ 
    		return 0;
    	}
    }
    
    int StackIsFull(Stack *s) { 
    	if (s->top == MAXNUM - 1) { 
    		return 1;
    	}
    	else
    	{ 
    		return 0;
    	}
    }
    
    // 入栈
    void StackPush(Stack *s, CAR car) { 
    	if (!StackIsFull(s)) { 
    		s->top++;
    		s->car[s->top] = car;
    	}
    }
    
    // 出栈
    CAR StackPop(Stack *s) { 
    	CAR car;
    	if (!StackIsEmpty(s)) { 
    		car = s->car[s->top];
    		s->top--;
    		return car;
    	}
    }
    
    // 获取栈顶元素
    CAR StackGetTop(Stack *s) { 
    	CAR car;
    	if (!StackIsEmpty(s)) { 
    		car = s->car[s->top];
    		return car;
    	}
    }
    
    // 队列初始化
    void QueueInit(CarChainQueue *q) { 
    	if (!(q->head = (CarNode *)malloc(sizeof(CarNode)))) { 
    		printf("队列初始化失败!\n");
    		exit(0);
    	}
    	// 头尾指针指向相同，表示队列为空
    	q->rear = q->head;
    	q->head->next = NULL;
    	q->rear->next = NULL;
    }
    
    // 入队
    void enQueue(CarChainQueue *q, CAR car) { 
    	CarNode *p;
    	if (!(p = (CarNode *)malloc(sizeof(CarNode)))) { 
    		printf("汽车入队失败!\n");
    		exit(0);
    	}
    	p->data = car;
    	p->next = NULL;
    	// 将新节点加入队列
    	q->rear->next = p;
    	q->rear = p;
    }
    
    // 出队
    CAR deQueue(CarChainQueue *q) { 
    	CarNode *p;
    	CAR car;
    	
    	// 当队列不为空时
    	if (q->head != q->rear) { 
    		// 取出队头的第一辆车
    		p = q->head->next;
    		// 当这辆车是最后一辆时
    		if (p->next == NULL) { 
    			car = p->data;
    			// 把队列置空
    			q->rear = q->head;
    			free(p);
    		}
    		else
    		{ 
    			// 当这辆车不是最后一辆时
    			// 第二辆车成为新的队头
    			q->head->next = p->next;
    			car = p->data;
    			free(p);
    		}
    		return car;
    	}
    }
    
    // 输出日期
    void printDate(struct tm gm_date) { 
    	printf("%d/%d %02d:%02d:%02d\n", gm_date.tm_mon+1, gm_date.tm_mday,
    		gm_date.tm_hour, gm_date.tm_min, gm_date.tm_sec);
    }
    
    // 输出相同字符
    void separator(char ch, int n) { 
    	int i;
    	printf("\t");
    	for (i = 0; i < n; i++) { 
    		printf("%c", ch);
    	}
    	putchar('\n');
    }
    
    // 查看目前停车情况
    void showPark(Stack *s) { 
    	int i;
    	struct tm gm_date;
    	printf("\n\t车位使用情况\n");
    	separator('-', 40);
    	if (StackIsEmpty(s)) { 
    		printf("\t停车场中目前没有车辆\n");
    	}
    	else { 
    		printf("\t位置\t车牌号\t\t进站时间\n");
    		for (i = 0; i <= s->top; i++) { 
    			printf("\t%3d\t", s->car[i].position);
    			printf("%s\t\t", s->car[i].num);
    			printDate(s->car[i].intime);
    		}
    		printf("\t\t\t共%d辆", s->top + 1);
    		if (StackIsFull(s)) { 
    			printf("(已满)\n");
    		}
    		else { 
    			printf("(还可停放%d辆)\n", MAXNUM - 1 - s->top);
    		}
    
    	}
    	separator('-', 40);
    
    }
    
    // 查看过道情况
    void showAisle(CarChainQueue *q) { 
    	if (q->head != q->rear) { 
    		CarNode *p;
    		p = q->head->next;
    		printf("\n\n\t过道使用情况\n");
    		separator('-', 30);
    		printf("\t车牌\t进入时间\n");
    		while (p != NULL)
    		{ 
    			printf("\t%s\t\t", p->data.num);
    			printDate(p->data.intime);
    			p = p->next;
    		}
    	}
    	else
    	{ 
    		printf("\n\t过道上没有车在等待\n");
    	}
    	separator('-', 30);
    }
    
    // 同时显示停车场和过道的使用情况 
    void showAll(Stack *s, CarChainQueue *q) { 
    	showPark(s);
    	showAisle(q);
    }
    
    // 车辆进入停车场
    void inPark(Stack *s, CarChainQueue *q) { 
    	CAR car;
    	// 时间结构体
    	struct tm *gm_date;
    	// 时间戳
    	time_t seconds;
    	//获取时间
    	time(&seconds);
    	// 把时间转化成时间结构体
    	gm_date = localtime(&seconds);
    
    	printf("\n\t请输入车牌号(最长10位)：");
    	scanf("%11s", car.num);
    	
    	while (strlen(car.num) > 10) { 
    		// 吸收多余的字符
    		while (getchar() != '\n') { 
    			getchar();
    		}
    		printf("\n\t请输入车牌号(最长10位)：");
    		scanf("%11s", car.num);
    	}
    	fflush(stdin);
    	car.intime = *gm_date;
    
    	// 当停车场有空闲车位 且 过道上没有车在等待时 入栈
    	if (!StackIsFull(s) && q->head == q->rear) { 
    		// 分配停车位
    		car.position = (s->top) + 2;
    		// 入栈(表示停车场)
    		StackPush(s, car);
    		// 显示目前停车场情况 
    		showPark(s);
    	}
    	else if (StackIsFull(s) || q->head != q->rear) { 
    		printf("\t提示：停车场车位已满，请先暂时在过道上停靠。\n");
    		car.position = MAXNUM;
    		// 入队(过道)
    		enQueue(q, car);
    		showAll(s, q);
    	}
    
    }
    
    // 打印车辆账单
    void printRate(CAR *car) { 
    	printf("\n\n\t 账单\n");
    	separator('-', 30);
    	printf("\t车牌:%s\n", car->num);
    	printf("\t车位:%d\n", car->position);
    	printf("\t进入时间：");
    	printDate(car->intime);
    	printf("\t离开时间：");
    	printDate(car->outtime);
    	printf("\t停车时长(秒）:%d\n", car->length);
    	printf("\t费用(元):%d\n", car->expense);
    	separator('-', 30);
    	printf("\n");
    }
    
    // 车辆离开停车场
    void outPark(Stack *s, CarChainQueue *q) { 
    	struct tm *gm_date;
    	time_t seconds;
    	// 临时栈
    	Stack tempStack;
    	int i, pos;
    	CAR car;
    
    	StackInit(&tempStack);
    
    	if (StackIsEmpty(s)) { 
    		printf("\t目前停车场为空!\n");
    		return;
    	}
    	else
    	{ 
    		printf("\t目前停车场使用情况如下:\n");
    		showPark(s);
    		fflush(stdin);
    		// 输出要离开车辆的车牌号
    		printf("\t哪个车位的车辆要离开:");
    		scanf("%d", &pos);
    		// 判断车牌号是否正确
    		if (pos > 0 && pos <= s->top + 1) { 
    			// 将要离开车辆后面的车辆暂时存放到临时栈中
    			for (i = s->top + 1; i > pos; i--) { 
    				// 取出栈顶的车
    				car = StackPop(s);
    				// 将停车位向前提一位
    				car.position = car.position - 1;
    				// 压入临时栈
    				StackPush(&tempStack, car);
    			}
    			// 取出要离开的车
    			car = StackPop(s);
    			// 获取当前时间
    			time(&seconds);
    			
    			gm_date = localtime(&seconds);
    
    			car.outtime = *gm_date;
    			// 计算停车时长，以秒为单位 
    			car.length = mktime(&car.outtime) - mktime(&car.intime);
    			// 计算停车费，以小时计费，不足一小时，按一小时收费
    			car.expense = (car.length / 3600 + 1)*PRICE;
    			// 打印发票
    			printRate(&car);
    
    			// 把临时栈中的车再放回停车场
    			while (!StackIsEmpty(&tempStack)) { 
    				car = StackPop(&tempStack);
    				StackPush(s, car);
    			}
    			// 如果停车场有空闲且过道上有车在等待，将等待的车辆放入停车场
    			while (!StackIsFull(s) && q->head != q->rear) { 
    				// 依次取出队列(过道)上的车
    				car = deQueue(q);
    				time(&seconds);
    				gm_date = localtime(&seconds);
    				car.intime = *gm_date;
    				StackPush(s, car);
    			}
    
    		}
    		else
    		{ 
    			printf("\t车位号输入错误，或该车位没有车辆!\n");
    		}
    	}
    
    }
    
    
    int main() { 
    	Stack park;				// 停车场 
    	CarChainQueue aisle;	// 过道
    	char choice;
    
    	StackInit(&park);
    	QueueInit(&aisle);
    	
    	do { 
    		printf("\n\n\t停车场管理系统\n");
    		separator('-', 30);
    		printf("\t1.车辆进入\n");
    		printf("\t2.车辆离开\n");
    		printf("\t3.查看停车场停放情况\n");
    		printf("\t0.退出系统\n");
    		separator('-', 50);
    		printf("\t提示：本停车场有%d个车位，停车场停满后，车辆只能停放在过道上.\n", MAXNUM);
    		printf("\t本停车场收费标准为：%.2f元/小时，停放在过道不收取费用\n\n", PRICE);
    		printf("\n\t请选择操作(0~3):");
    
    		choice = getchar();
    		// 判断当前读到的是有效字符，还是无意义的回车
    		if (choice == '\n') { 
    			choice = getchar();
    		}
    		// 吸收多余的字符
    		while (getchar() != '\n') { 
    			getchar();
    		}
    		
    		switch (choice)
    		{ 
    			case '1':
    				inPark(&park, &aisle);
    				break;
    			case '2':
    				outPark(&park, &aisle);
    				break;
    			case '3':
    				showAll(&park, &aisle);
    				break;
    		}
    
    
    	} while (choice != '0');
    
    	return 0;
    }