栈和队列应用

/************************************************************
--程序描述：	上机实验2__栈和队列及其应用.doc（有描述）
--修改记录：	从前写的代码不够规范——2009.6.17
--修改人：		吴强	
--输入要求：	A|D|E, 到达时间,离开时间,车的类型
		（'A'表示Arrival, 'D'表示Departure, 'E'表示输入结束End）
************************************************************/

#include 
#include 


#define MAX 3   //停车场车位数

typedef struct car
{
	char	AorD;
	int	numb;
	int	time;
	int	CarType;  //1为小汽车，2为客车，3为货车
}infCar;

//definition stack
class Stack
{
private:
	infCar	stack[MAX];   
	int	Top;

public:
	Stack()
	{ 
		Top = -1; 
	}

	void Push(infCar A);
	infCar* Pop();
	infCar* GetTop();
	int Empty();
	int IsFull();
	int TopVal();
};

infCar* Stack::Pop()
{
	infCar	d;

	if (Top != -1)
	{
		d = stack[Top];
		Top--;
		return &stack[Top+1];
	}
	else 
	{
		printf("栈空，无法删除/n");
		return NULL;
	}
}	

void Stack::Push(infCar A)
{
	if (MAX-1 == Top)
	{
		printf("栈满，无法在进入/n");
		return ;
	}

	Top++;
	stack[Top] = A;
}

infCar* Stack::GetTop()
{
	if (Top != -1)
	{
		return &stack[Top];
	}
	else 
	{
		return NULL;
	}
}

int Stack::Empty()
{
	if (Top == -1)
	{
		return 1;
	}
	else 
	{
		return 0;
	}
}

int Stack::IsFull()
{
	if (MAX-1 == Top)
	{
		return 1;
	}
	else 
	{
		return 0;
	}
}

int Stack::TopVal()
{
	return Top+1;   //数组从0开始，车位从1开始
}

//definition queue
typedef struct queN 
{
	infCar	data;
	struct	queN *next;
}queNode;

class Queue
{
private:
	queNode	head;
	queNode	*front;
	queNode *rear;

public:
	Queue();
	void Push(infCar d);
	infCar Pop();
	infCar GetHead();
	int Empty();
	int GetLen();
};

Queue::Queue()
{
	head.next = NULL;
	front = rear = &head;	
}

void Queue::Push(infCar d)
{	
	queNode	*p;

	p = new queNode;
	p->data = d;
	p->next = NULL;
	rear->next = p;
	rear = p;
}

infCar Queue::Pop()
{
	infCar	d;
	queNode	*p;

	if (front == rear)
	{
		printf("队列为空，无法删除");
		return front->data;
	}

	p = front->next;
	front->next = p->next;

	if (rear == p)
	{
		rear=front;
	}

	d = p->data;

	delete(p);
	return d;
}

infCar Queue::GetHead()
{
	infCar d;

	d = front->next->data;

	return d;
}

int Queue::Empty()
{
	if (front == rear)
	{
		return 1;
	}
	else 
	{
		return 0;
	}
}

int Queue::GetLen()
{
	int	k=0;
	queNode	*p;

	p = front;

	while (p->next != NULL)
	{
		k++;
		p = p->next;
	}

	return k;
}
//////////////////////////////////////////////////////////
//main

void main()
{
	Stack	staPar;
	Stack	sta;
	Queue	queAis;
	infCar	val;
	infCar	rel;

	scanf("%c,%d,%d,%d", &val.AorD, &val.numb, &val.time, &val.CarType);

	fflush(stdin);

	while(val.AorD != 'E')
	{
		if (val.AorD == 'A')
		{
			if (!staPar.IsFull())
			{
				staPar.Push(val);
				printf("in the park  %d/n", staPar.TopVal());
			}
			else 
			{
				queAis.Push(val);
				printf("in the aisle  %d/n", queAis.GetLen());
			}
		}
		else if (val.AorD == 'D')
		{
			int ParN = 0;  //记录从staPar出栈
			int ProN = 0;		//记录staPro入栈的个数

			while(!staPar.Empty())
			{	
				rel = *staPar.Pop();
				ParN++;

				if (rel.numb == val.numb)
				{
					int tim = val.time-rel.time;

					printf("time is: %d:/n", tim);

					switch (rel.CarType)
					{
					case 1:
						{
							printf("money is: %d/n", tim*1);
							break;
						}
					case 2:
						{
							printf("money is: %d/n", tim*2);
							break;
						}
					case 3:
						{
							printf("money is: %d/n", tim*3);
							break;
						}
					default:
						{
							printf("input CarType error!/n");
						}
					}
					break;
				}

				sta.Push(rel);
				ProN++;
			}

			if (ParN == ProN)
			{
				printf("Is not char or Not in park!/n");
			}

			while(!sta.Empty())
			{
				rel = *sta.Pop();
				staPar.Push(rel);
			}

			if (!queAis.Empty())
			{
				staPar.Push(queAis.Pop());
			}
		}
		else 
		{
			printf("Without this order!/n");
		}

		scanf("%c,%d,%d,%d", &val.AorD, &val.numb, &val.time, &val.CarType);
		fflush(stdin);
	}
}