/*实验 栈和队列实验
实验目的
熟悉栈和队列的基本特性，掌握栈和队列基本运算的实现过程。
时间要求：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;
}
没有找出错误。。。。很难受？？？？？？？？？？？？？？
