ZZU数据结构与算法实验_1

ZZU数据结构与算法实验_1

问题描述

设停车场内只有一个可停放$n$辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已停满$n$辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入，当停车场内某辆车要离开时，在它之后开入的车辆必须先退出车场为它让路，待该辆车开出大门外，其它车辆再按原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。试为停车场编制按上述要求进行管理的模拟程序。

要求：

以栈模拟停车场，以队模拟停车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”和“离去”信息、汽车牌照号码及到达和离去的时刻，对每一组输入数据进行操作后的输出数据为：若是车辆到达，则输出汽车在停车场内或便道上停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用（在便道上停留的时间不收费）。栈以顺序结构实现，队列以链表结构实现。

测试数据：

设n=2，输入数据为：（‘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）。其中：‘A’表示到达；‘D’表示离去；‘E’表示输入结束。

solve_0

建两个栈，一个用于模拟停车场，一个用来存放停车场中非栈顶元素出栈时该元素上面的元素

建一个队列用于存放停车场停满时的等待车辆

用这三个数据结构模拟整个过程即可

#include<stdio.h>
#include<stdlib.h>
const int fee = 2;
const int MAX_CAR = 2;
int cnt;		//记录等待车辆在队列中的位置

typedef struct {
	int carnumber;
	int arrtime;
} Car;			//定义Car结构体

typedef struct {
	Car* cars;
	int top;
	int size;
}stack;			//定义栈

typedef struct Node {
	Car car;
	struct Node* next;
}queue;			//定义队列

typedef struct {
	queue* front;
	queue* rear;
}waitingnode;	

int stackisfull(stack* s) {				//判断是否停满
	return s->top == s->size - 1;
}				

void initstack(stack* s, int n) {		//初始化栈
	if (!stackisfull(s)) {
		s->cars = (Car*)malloc(n * sizeof(Car));
		s->top = -1;
		s->size = n;
	}
}				

void initwaitingnode(waitingnode* n) {	//初始化队列
	n->front = NULL;
	n->rear = NULL;
}


int stackisemp(stack* s) {				//判断栈是否为空
	return s->top == -1;
}

int queueisemp(waitingnode* w) {		//判断队列是否为空
	return w->front == NULL;
}

void instack(stack* s, Car c) {			//入栈
	if (!stackisfull(s)) {
		s->top++;
		s->cars[s->top] = c;
		printf("car: %d pos: %d\n",c.carnumber, s->top + 1);
	}
}

void inqueue(waitingnode* w, Car c) {	//入队
	cnt++;
	queue* node = (queue*)malloc(sizeof(queue));
	node->car = c;
	node->next = NULL;
	if (queueisemp(w)) {
		w->front = node;
		w->rear = node;
	}
	else {
		w->rear->next = node;
		w->rear = node;
	}
}

void qtos(stack* s, waitingnode* w) {	//从等待区域进入停车场
	if (!queueisemp(w) && !stackisfull(s)) {
		queue* node = w->front;
		w->front = node->next;
		if (w->front == NULL) {
			w->rear = NULL;
		}
		if (!stackisfull(s)) {
			instack(s, node->car);
		}
		free(node);
		cnt--;
	}
}

void stot(stack* s, stack* tmp) {		//当非栈顶元素出栈时该元素上面的元素
	Car car = s->cars[s->top];
	s->top--;
	tmp->top++;
	tmp->cars[tmp->top] = car;
}

void ttos(stack* s, stack* tmp) {		//临时栈中元素返回停车场栈
	while (tmp->top >= 0) {
		Car car = tmp->cars[tmp->top];
		s->top++;
		s->cars[s->top] = car;
		tmp->top--;
		printf("car: %d pos: %d\n",car.carnumber, s->top + 1);
	}
}

void outstack(stack* s, int carnumber, int currtime) {		//出栈（适用于栈中所有元素）
	stack* tmp = (stack*)malloc(sizeof(stack));
	initstack(tmp, s->size);
	int found = 0;
	while (!stackisemp(s)) {
		Car car = s->cars[s->top];
		if (car.carnumber == carnumber) {
			found = 1;
			printf("car: %d time: %d fee:%d\n",car.carnumber, currtime - car.arrtime, (currtime - car.arrtime) * fee);
			s->top--;
			break;
		}
		stot(s, tmp);
	}
	ttos(s, tmp);
	if (!found) {
		printf("No such car!\n");
	}
}

int main() {
    //一堆初始化
	stack* park = (stack*)malloc(sizeof(stack));
	waitingnode* wait = (waitingnode*)malloc(sizeof(waitingnode));
	initstack(park, MAX_CAR);
	stack* tmp = park;
	initwaitingnode(wait);
	Car c;
    
    //直接模拟
 	char car_state;
	while (scanf(" %c %d %d", &car_state, &c.carnumber, &c.arrtime) && (car_state != 'E')) {
		if (car_state == 'A') {
			if (stackisfull(park)) {
				inqueue(wait, c);
				printf("the park is full, car: %d waiting_pos: %d\n", c.carnumber, cnt);
			}
			instack(park, c);
		}
		else if (car_state == 'D') {
			outstack(park, c.carnumber, c.arrtime);
			qtos(park, wait);
		}
	}
	free(park);
	free(wait);
	return 0;
}