数据结构栈和队列（以停车场管理题目为例）

版权声明：如要转载，请注明出处，谢谢 https://blog.csdn.net/yezonghui/article/details/79457781

/*实验 栈和队列实验

实验目的
熟悉栈和队列的基本特性，掌握栈和队列基本运算的实现过程。
时间要求：4+4学时
问题描述：
设停车场内只有一个可停放 n 辆汽车的狭长通道，且只有一个
大门可供汽车进出，汽车在停车场内按车辆到达时间的先后顺序，
依次由北向南排列（大门在最南端，最先到达的第一辆车停放在
车场
的最北端），若车场内已停满 n 辆汽车，则后来的汽车只能在
门外的便道上等候, 一旦有车开走，则排在便道上的第一辆车即可
开入，当停车场内某辆车要离开时，在它之后开入的车辆必须先
退出车场为它让路，待该辆车开出大门外，其它车辆再按原次序
进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的
时间长短交纳费用，当便道上汽车要离开时，排在它前面的汽车要
先开走让路，然后再依次排到队尾，并且在便道上停车不收费。
试为停车场编制按上述要求进行管理的模拟程序。
基本要求：
以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的
输入数据序列管理，每一组输入数据包括三个数据项：
汽车“到达”或“离去”信息、汽车牌照号码及到达或离去的时间，


对每一组输入数据进行操作后的输出数据为： 若是车辆到达，
则输出汽车在停车场内或便道上的停车位置；若是车辆离去，
则输出汽车在停车场内停留的时间和应交纳的费用（在便递上
停留的时间不收费），栈以顺序结构实现，队列以链表结构实现。


实现提示：
需另设一栈，临时停放为给要离去的汽车让路而从停车场退出
来的汽车，也用顺序存储结构实现。输入数据按到达或离去的
时刻有序。栈中每个元素表示一辆汽车，包含有两个数据项：
汽车牌照号码和进入停车场的时间。
选作内容：
（1）两个栈共享空间，思考应开辟数组的空间是多少 ?
（2）汽车可有不同种类，则它们的占地面积不同，收费标准也
不同，如 1 辆客车和 1.5 辆小汽车的占地面积相同，1辆十轮
卡车占地面积相当于3辆小汽车的占地面积 。
（3）停放在便道上的汽车也收费，收费标准比停放在停车场的
车低，请思考如何修改结构以满足这神要求。
Input
输入第一行，包括两个数据，第一个整数为停车场最多可停放
车辆数，第二个浮点数表示单位时间的停车费用。接下来有多
行数据，每行有三个整数，第一个为0或1，0表示进入车场，
1表示离开车场；第二个整数为车号；第三个整数为进入或离开
的时间。当一行中三个数均为0时表示输入结束，所有数据之间
由空格分隔。
Output
输出为三部分，第一部分为按离开停车场顺序打印出的各车费用，
每车一行，包括车号和费用(保留小数点后两位)。第二部分占一行
为当前停车场中的所有车辆，从北到南顺序输出各车车号。
第三部分占一行为当前便道上的所有车辆，从前向后顺序输出
各车车号。各车号之间由一个空格分隔。
Sample Input
2  1.5
0  1  5
0  2  10
1  1  15
0  3  20
0  4  25
0  5  30
0  6  35
1  2  40
0  7  45
1  6  50
0  0  0
Sample Output
1  15.00 
2  45.00
3  4
7  5*/

代码实现如下：

#include<algorithm>
#include<cstdio>
#include<stdlib.h>
//#include<bits/stdc++.h>
using namespace std;
int park_size=0;
float park_price=0;
typedef struct{
	int num;
	int time;
	int outime;
}park_data;
typedef struct{
	park_data *base;
	park_data *top;
	int stacksize;
}Sqstack;
typedef struct QNode{
	park_data data;
	struct QNode *next; 
}QNode,*Queueptr;
typedef struct{
	Queueptr front;
	Queueptr rear;
}LinkQueue;
void Initstack(Sqstack *S); //chushihu zhan			
void InitQueue(LinkQueue *Q); //chushihua duilir			
void deal(Sqstack *p_stack,LinkQueue *p_queue,park_data D,int flag); // chulijisuan			
void Push(Sqstack *S,park_data D); //ruzhan			
void Pop(Sqstack *S,park_data *D); //chuzhan bingshuchu jieguo 			
void EnQueue(LinkQueue *p_queue,park_data D); //ru duilie			
void DeQueue(LinkQueue *Q,park_data *D); //chu duilie			
void search(Sqstack *p_stack,LinkQueue *p_queue,park_data D);			//chazhao bing shuchu
void Sprint(Sqstack p_stack);
void Qprint(LinkQueue p_queue);
/*
void Initstack(Sqstack * S)
{
	(*S).top=(*S).base;
	S->stacksize=park_size;
}
void Push(Sqstack *S,park_data D)
{
	*(S->top)=D;
	S->top++;
}*/
/*
void Pop(Sqstack *S,park_data *D)
{
	S->top--;
	*D=*(S->top);
}
void InitQueue(LinkQueue *Q)
{
	(*Q).rear=(*Q).front; 
} 
void EnQueue(LinkQueue *Q,park_data D)
{
	Queueptr p=(Queueptr)malloc(sizeof(QNode));
	p->data=D;
	p->next=NULL;
	Q->rear->next=p;
	Q->rear=p;
}
void DeQueue(LinkQueue *Q,park_data *D)
{
	Queueptr p=Q->front->next;
	p=Q->front->next;
	*D=p->data;
	Q->front->next=p->next;
	free(p); 
}*/
void Initstack(Sqstack *S){			
	(*S).base = (park_data *)malloc(park_size*sizeof(park_data));		
	if(!(*S).base)		
		printf("fail Initstack!\n");	
	(*S).top=(*S).base;		
	S->stacksize=park_size;		
}			
			
void InitQueue(LinkQueue *Q){			
	(*Q).front=(Queueptr)malloc(sizeof(QNode));		
	(*Q).rear=(*Q).front;		
	if(!(*Q).front)		
		printf("fail InitQueue!\n");	
}
		void Push(Sqstack *S,park_data D){			
	if((S->top-S->base)>=park_size)		
		printf("you got error when push\n");
	
//	printf("you are pushing\n");
			
	*(S->top)=D;		
	S->top++;		
}			
			
void Pop(Sqstack *S,park_data *D){			
	if(S->base==S->top)		
		printf("you got reeor when pop\n");	


//	printf("you are poping\n");
			
	S->top--;		
	*D=*(S->top);		
}			
			
void EnQueue(LinkQueue *Q,park_data D){			
	Queueptr p=(Queueptr)malloc(sizeof(QNode));		
			
	if(!p)		
		printf("you got error when enqueue\n");	


//	printf("you are enqueueing\n");
			
	p->data=D;		
	p->next=NULL;		
	Q->rear->next=p;		
	Q->rear=p;		
}			
			
void DeQueue(LinkQueue *Q,park_data *D){			
	Queueptr p=Q->front->next;		
			
	if(Q->front==Q->rear){		
		printf("you got error when dequeue\n");	
		return;
	}


//	printf("you are dequeueing\n");
			
	p=Q->front->next;		
	*D=p->data;		
	Q->front->next=p->next;		
			
	if(Q->rear==p)		
		Q->rear=Q->front;	
			
	free(p);		
}	


void search(Sqstack *p_stack,LinkQueue *p_queue,park_data D)
{
	Sqstack q_stack;     //linshi zhan 
	LinkQueue q_queue;      //linshi duilie 
	park_data D_temp;		
	int flag=0;		
			
	Initstack(&q_stack);
	InitQueue(&q_queue);
	
	while(1)
	{
		if((p_stack->top-1)->num==D.num)
		{
			flag=1;
			Pop(p_stack,&D_temp);
			printf("%d %.2f\n",D_temp.num,(D.time - D_temp.time)*park_price);
			if(p_queue->front!=p_queue->rear)
			{
				DeQueue(p_queue,&D_temp);
				D_temp.time=D.time;
				Push(p_stack,D_temp);
			}
			break;
		}
		else
		{
			Pop(p_stack,&D_temp);
			Push(&q_stack,D_temp);
		}
		if(p_stack->top==p_stack->base)
		break;
	 } 
	 while(q_stack.top!=q_stack.base)
	 {
	 	Pop(&q_stack,&D_temp);
	 	Push(p_stack,D_temp);
	 }
	 if(flag==0)
	 {
	 	while(p_queue->front!=p_queue->rear)
	 	{
	 		if(p_queue->front->next->data.num==D.num)
	 		{
	 			DeQueue(p_queue,&D_temp);
	 			flag=1;
			 }
			 else{
			 	DeQueue(p_queue,&D_temp);
			 	EnQueue(&q_queue,D_temp);
			 }
		 }
		 while(q_queue.front!=q_queue.rear)
		 {
		 	DeQueue(&q_queue,&D_temp);
		 	EnQueue(p_queue,D_temp);
		 }
	 }
}
			


void Sprint(Sqstack p_stack)
{
	park_data D;
	while(1)
	{
		Pop(&p_stack,&D);
		printf("%d ",D.num);
		if(p_stack.top==p_stack.base)
		break;
	}
	printf("\n");
}
void Qprint(LinkQueue p_queue)
{
	park_data D;
	Sqstack q_stack;
	Initstack(&q_stack);
	while(p_queue.front!=p_queue.rear)
	{
		DeQueue(&p_queue,&D);
		Push(&q_stack,D); 
	}
	while(1){		
		Pop(&q_stack,&D);	
		printf("%d ",D.num);
		if(q_stack.top==q_stack.base)
			break;
		}
}
void deal(Sqstack *p_stack,LinkQueue *p_queue,park_data D,int flag){
	if(flag==0)
	{
		if((p_stack->top-p_stack->base)<park_size)
		{
			Push(p_stack,D);
		}
		else
		{
			EnQueue(p_queue,D);
		}
	}
	else
	{
		search(p_stack,p_queue,D); 
	} 
}


int main()
{
	


	Sqstack p_stack;
	LinkQueue p_queue;
	park_data D;
	int flag=0;
	printf("park_size and price\n");
	scanf("%d%f",&park_size,&park_price);
	Initstack(&p_stack);
	InitQueue(&p_queue);
	do{
		scanf("%d%d%d",&flag,&D.num,&D.time);
		if(D.num==0)
		break;
		deal(&p_stack,&p_queue,D,flag);
	}while(1);
	Sprint(p_stack);
	Qprint(p_queue);
	return 0;
 } 

编程出发：1.按照题目要求，定义栈的结构，数据结构，队列结构；

                2.进行栈的初始化，进栈函数操作，出栈函数操作，队列初始化，进队列，出队列函数操作

                  （其实这些操作的原理还是比较容易的，主要就是注意一些空间生成，&/*/->符号理解，错误说明等）

                3.进行题意得分析，注意各个细节，可借助草图进行理解

                4.主函数的编写，进行栈，队列，数据，到达还是离开的标志的定义声明，然后使用do - while结构进行数据输入

                5.写deal处理函数，判断flag标志，确定车是到达还是离开。

                6.当车是进来时，进行入栈或者入队列操作；当车出去时，我们需要先做一些准备工作，定义一些临时栈，临时队列，临时数据变量。然后对于这些临时得栈我们也是要进行初始化的。

                 7.车出去时也是分为两种情况：从栈出去（又分为车在栈顶，车不在栈顶）；从队列出去（在队头，不在队头）

                 8.最后设计数据输出函数。（其实也就是要把栈和队列的数据输出来，即遍历的过程）

现在我的想法就是能不能使用STL解决这个题目

我打算使用stl里面的queue和stack时却遭遇了困难。

编译过来但是调式不出来。

#include<cstdio>
#include<iostream>
#include<stack>
#include<queue>
using namespace std;
int park_size=0;
float park_price=0;
typedef struct{
	int num;
	int time;
	int outime;
}park_data;
void search(stack <park_data> p_stack,queue <park_data> p_queue,park_data D);
void deal(stack<park_data> p_stack,queue<park_data> p_queue,park_data D,int flag);
void deal(stack<park_data> p_stack,queue<park_data> p_queue,park_data D,int flag){			
	if(flag==0){		
		if((p_stack.size())<park_size)		
			p_stack.push(D);	
		else		
			p_queue.push(D);	
	}		
	else{		
		search(p_stack,p_queue,D);	
	}		
}			
		
void search(stack <park_data> p_stack,queue <park_data> p_queue,park_data D)
{	
    stack<park_data> q_stack;
	queue<park_data> q_queue;
	park_data D_temp;
	int flag=0;		
	while(1){		
		if((p_stack.top().num) ==D.num){	
			flag=1;
			D_temp=p_stack.top();
			p_stack.pop();
			printf("%d %.2f\n",D_temp.num,(D.time-D_temp.time)*park_price);
			if(p_queue.size()!=0)
			{
				D_temp=p_queue.front();
				p_queue.pop( );
				D_temp.time=D.time;
				p_stack.push(D_temp);
			}
			break;
		}
		
		else{	
		    D_temp=p_stack.top();
			p_stack.pop( );
			p_stack.push(D_temp);
		}

		if(p_stack.size()!=0)
			break;
	}		

	while(q_stack.size()!=0)
	{		
	    D_temp=q_stack.top();
		q_stack.pop( );	
		p_stack.push(D_temp);
	}		
			
	if(flag==0){
		while(p_queue.size()!=0){
			if(p_queue.front().num==D.num)
			{
				D_temp=p_queue.front();
				p_queue.pop();
			//	printf("lie num:%d\n",D_temp.num);
				flag=1;
			}	
			else
			{	
			    D_temp=p_queue.front();   
				p_queue.pop();
				q_queue.push(D_temp);
			}
		}

		while(q_queue.size()!=0){
		    D_temp=q_queue.front();	
			q_queue.pop();	
			p_queue.push(D_temp);
		}
	}
			
	if(flag==0)		
		printf("wrong info\n");	
}
void Sprint(stack <park_data> p_stack){
	park_data D;

	while(1){	
	    D=p_stack.top();	
		p_stack.pop();
		printf("%d ",D.num);
		if(p_stack.size()==0)
			break;
	}

	printf("\n");
}			

void Qprint(queue<park_data> p_queue)
{
	park_data D;
	stack<park_data> q_stack;
	while(p_queue.size()!=0)
	{	
	    D.num=p_queue.front().num;
		p_queue.pop();
		q_stack.push(D);	
	}

	while(1){
	    D=q_stack.top();
		q_stack.pop();			
		printf("%d ",D.num);
		if(q_stack.size()==0)
			break;
	}

	printf("\n");
}		
int main()
{
	stack<park_data> p_stack;
    queue<park_data> p_queue;
    park_data D;
    int flag;
    printf("park_size and price\n");
    scanf("%d%f",&park_size,&park_price);
    do{
    	cin>>flag>>D.num>>D.time;
    	if(D.num==0)break;
    	deal(p_stack,p_queue,D,flag);
	}while(1);
	Sprint(p_stack);
	Qprint(p_queue);
	return 0;
 } 

没有找出错误。。。。很难受？？？？？？？？？？？？？？