设停车场内只有一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间 10
依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），若车场内已停满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’表示输入结束。
【实现提示】需另设一个栈，临时停放为给要离去的汽车让路而从停车场退出来的汽车，也用顺序存储结构实现。输入数据按到达或离去的时刻有序。栈中每个元素表示一辆汽车，包含两个数据项：汽车的牌照号码和进入停车场的时刻。
import java.util.Scanner;
public class tingchechangxitong {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入车库大小和每小时收费：");
int size = sc.nextInt();
int cost = sc.nextInt();
int p = 0,q = 0,hm,sj,i=0,wz=0,j=0,bwz = 0;
char c;
System.out.print(size + " " + cost);
base [] ck1 = new base[size]; //车库大小一定
base [] ck2 = new base[size];
base [] ck3 = new base[100]; //假设便道可以放无限的车
based(ck1,size);
based(ck2,size);
based(ck3,100);
while(true){
System.out.println("输入数据：\n");
c = sc.next().charAt(0);
if(c == 'e'||c == 'E'){
System.out.println("结束使用");
break;
}
hm = sc.nextInt();
sj = sc.nextInt();
if(c == 'a'||c == 'A')
if(p<size){
ck1[p].hm = hm;
ck1[p].sj = sj;
System.out.println(hm + "号车进入车库" + (p+1) + "WZ");
p++;
System.out.println("现在车库内的车辆为(从里往外)：");
for( i = 0;i<p;i++){
System.out.print(ck1[i].hm + " ");
System.out.println();}
}else{
ck3[q].hm = hm;
ck3[q].sj = sj;
System.out.println(hm + "号车进入便道"+ (q+1) + "WZ");
q++;
}
if(c == 'd'||c == 'D'){
for(i=0;i<size;i++){
if(ck1[i].hm == hm){
System.out.println(hm + "号车离开车库"+ (i+1) + "WZ" + "总花费：" + (sj-ck1[i].sj)*cost);
p--;
wz=i;
break;
}
}
//changeWZ(ck1,wz,p);//
//
ZchangeWZ(ck1,ck2,wz,size-1);//栈实现
//
System.out.println("现在车库内的车辆为(从里往外)：");
for( i = 0;i<p;i++){
System.out.print(ck1[i].hm + " ");
System.out.println();
}
//实现便道的车进入车库
if(p<size)
{
if(q>0)
{
//for(i=0,j=p;j<size && i<q;i++,j++){
// ck1[j].hm = ck3[i].hm;
ck1[p].hm = ck3[0].hm;
// ck1[j].sj = ck3[i].sj;
ck1[p].sj = ck3[0].sj;
// bwz = i-1;
BDchangeWZ(ck1,ck3,bwz,q);//队列实现
p++;
q--;
System.out.println("便道车入车库");
System.out.println("现在车库内的车辆为(从里往外)：");
for( i = 0;i<p;i++){
System.out.print(ck1[i].hm + " ");
System.out.println();}
}
/*if(q>0){
ck1[size-1].hm = ck3[i].hm;
ck1[j].sj = ck3[i].sj;
bwz = i-1;
BDchangeWZ(ck1,ck3,bwz,q-1);//队列实现
p++;
q--;
}*/
}
if(p==0)
System.out.print("NULL\n");
}
}
}
//
//数据 3 3 a 1 1 a 2 2 a 3 3 a 4 4 a 5 5
//
//
/**
* 相应函数
* @param ck
* @param size
*/
//基于base的数组
public static void based(base[]ck,int size)
{
for(int i=0;i<size;i++)
{
ck[i] = new base();
}
}
/* public static void changeWZ(base[]ck,int w,int p){//直接覆盖实现车辆的出车库
for(int i = w;i<p;i++){
ck[i].hm = ck[i+1].hm;
}
}*/
public static void ZchangeWZ(base[]ck1,base[]ck2,int w,int s){//栈的思想实现
int i,j;
for( i = s,j = 0;i>w;i--,j++){
ck2[j].hm = ck1[i].hm;
ck2[j].sj = ck1[i].sj;
}//前面的车让道
int k = j-1;
for(i = w, j = k;j>=0;i++,j--){
ck1[i].hm = ck2[j].hm;
ck1[i].sj = ck2[j].sj;
}
}
public static void BDchangeWZ(base[]ck1,base[]ck3,int w,int s){//队列的思想实现
int j;
for(j = 0;j<s-1;j++){
ck3[j].hm = ck3[j+1].hm;
ck3[j].sj = ck3[j+1].sj;
// w--;
}//前面的车进入车库
}
}
//基础类
class base {
int hm;
int sj;
}
