停车场管理系统 数据结构 Java语言

题目

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

示意图

设计思路

根据题目分析我采用的是链队列和栈。分析可知：需要两个栈和一个队列。两个栈分别是停车栈和缓冲栈。队列是候车场。
(1)停车栈：南边封口，汽车只能从北边进出。满足栈的特性，需要使用栈数据结构。
(2)缓存栈：停车场的车要离开时，在该车后面的车辆要先退出车场为它让路，车离开后，在按原次序进入车场。根据分析，使用栈的数据结构。
(3)候车场：停车场停满时，后来的汽车只能在过道上等候，有车开走，则排在过道上的第一辆车即可开入。可以看出候车场是先进先出，满足队列的特性，需要使用队列的数据结构。
(4)车离开停车场时，要按停留的实际长短交纳费用，需要记录车进入停车场的时间。
(5)写出一个菜单界面，用于操作和显示。
下面开始实现一个有5个停车位的停车场

类设计

Car类：汽车的实体类

MyStack接口：栈的接口
InStack类：停车场栈
OutStack类：汽车离开停车场的缓冲栈

QueueNode类：链队列的结点
Queue类：候车场队列

Parking类：运行类，菜单
InOutCar类：实现各种进入出入停车场方法

如下图所示：

Car实体类

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 汽车类
 */
public class Car {

    private String number;  //车牌号
    private Date inTime;    //汽车进入停车场的时间
    private Date outTime;   //汽车退出停车场的时间

    public Car(){
        this.number="";
        inTime=null;
        outTime=null;
    }

    public Car(String num){
        this.number=num;
        inTime=null;
        outTime=null;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getInTime() {
        SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        return f.format(inTime);
    }

    public void setInTime(Date inTime) {
        this.inTime = inTime;
    }

    public String getOutTime() {
        SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        return f.format(outTime);
    }

    public void setOutTime(Date outTime) {
        this.outTime = outTime;
    }
}

MyStack接口

public interface MyStack {
    void push(Car car);     //入栈
    Car pop();              //出栈
    boolean isFull();       //判断是否满了
    boolean empty();        //判断是否为空
    int getLength();        //当前栈的元素数量
}

InStack类

import java.util.Date;

/**
 * 停车场
 */
public class InStack implements MyStack {
    private int maxsize;
    private int top;
    private Car[] inCar;

    public InStack(){
        maxsize = 5;
        inCar = new Car[maxsize];
        top = -1;
    }

    //入栈 同时将系统时间压入
    public void push(Car car) {
        Date time = new Date(); //时间类
        car.setInTime(time);
        inCar[++top] = car;
    }

    //入栈 不将系统时间压入
    public void pushNoTime(Car car){
        inCar[++top] = car;
    }

    @Override
    public Car pop() {
        Car item = null;
        if (!empty()){
            item=inCar[top--];
            item.setOutTime(new Date());
        }
        return item;
    }

	public Car popNoTime(){
        Car item = null;
        if (!empty()){
            item = inCar[top--];
        }
        return item;
    }

    @Override
    public boolean isFull(){
        if (top == maxsize - 1){
            return true;
        }else{
            return false;
        }
    }

    @Override
    public boolean empty(){
        if (top == -1){
            return true;
        }else{
            return false;
        }
    }

    public int getLength() {
        return top + 1;
    }

    public Car getTop() {
        return inCar[top];
    }

    public void print(){
        for (int i = 0;i < getLength();i++){
            System.out.printf("%3d %12s %21s",(i+1),inCar[i].getNumber(),inCar[i].getInTime());
            System.out.println();
        }
    }
}

OutStack类

/**
 * 汽车离开停车场的缓冲栈
 */
public class OutStack implements MyStack {
    private int maxsize;
    private int top;
    private Car[] outCar;

    public OutStack(){
        maxsize = 5;
        outCar = new Car[maxsize];
        top = -1;
    }

    //判断是否满了
    public boolean isFull(){
        if (top == maxsize - 1){
            return true;
        }else{
            return false;
        }
    }

    //入栈
    public void push(Car car) {
        if (!isFull()){
            outCar[++top] = car;
        }
    }

    //出栈
    public Car pop(){
        Car item = null;
        if (!empty()){
            item=outCar[top--];
        }
        return item;
    }

    //判断是否为空
    public boolean empty(){
        if (top == -1){
            return true;
        }else{
            return false;
        }
    }

    public int getLength() {
        return top + 1;
    }
}

QueueNode类

/**
 * 链队列的结点
 */
public class QueueNode {
    private Car data;
    private QueueNode next;

    QueueNode(){}

    public QueueNode(Car item) {
        data = item;
    }

    public Car getData() {
        return data;
    }

    public void setData(Car data) {
        this.data = data;
    }

    public QueueNode getNext() {
        return next;
    }

    public void setNext(QueueNode next) {
        this.next = next;
    }
}

Queue类

/**
 * 候车场队列
 */
public class Queue {
    private QueueNode front; //队列头指示器
    private QueueNode rear;  //队列尾指示器
    private int maxsize;        //队列的容量，假如为0，不限容量
    private int size;           //队列数据元素个数

    //初始化链队列
    public Queue(){
        front = rear = null;
        size = 0;
        maxsize = 0;
    }

    public Queue(int maxsize){
        super();
        this.maxsize = maxsize;
    }

    public boolean isEmpty(){
        if ((front == rear) && (size == 0)){
            return true;
        }else{
            return false;
        }
    }

    public boolean isFull(){
        if (maxsize != 0 && size == maxsize){
            return true;
        }else{
            return false;
        }
    }

    public boolean enqueue(Car car){
        QueueNode newnode = new QueueNode(car);
        if (!isFull()){
            if (isEmpty()){
                front = newnode;
                rear = newnode;
            }else{
                rear.setNext(newnode);
                rear = newnode;
            }
            ++size;
            return true;
        }else
        {
            return false;
        }
    }

    public Car dequeue(){
        if (isEmpty()) return null;
        QueueNode node = front;
        front = front.getNext();
        if (front == null){
            rear = null;
        }
        --size;
        return node.getData();
    }

    public Car peek(){
        if (!isEmpty()){
            return front.getData();
        }else
            return null;
    }

    public Integer getSize(){
        return size;
    }

    public void print() {
        QueueNode queue = front;
        for (int i = 0;i < size;i++){
            System.out.printf("%2d %9s",(i+1),queue.getData().getNumber());
            System.out.println();
            queue = queue.getNext();
        }
    }
}

Parking类

import java.util.Scanner;

/**
 * 运行类，菜单
 */
public class Parking {

    public InOutCar inOutCar;
    private static Integer price = 1;

    //构造方法
    public  Parking(){
        inOutCar = new InOutCar();
    }

    public void menu(){
        System.out.println("    停车场管理系统     ");
        System.out.println("---------主菜单---------");
        System.out.println("    (1)车辆到达");
        System.out.println("    (2)车辆离开");
        System.out.println("    (3)显示停车场信息");
        System.out.println("    (4)显示等待车辆信息");
        System.out.println("    (5)修改单价");
        System.out.println("    (0)退出系统");
        Scanner scanner = new Scanner(System.in);

        while (true){
            System.out.println();
            System.out.print("请选择(1,2,3,4,5,0)：");
            Integer menuIndex = scanner.nextInt();
            String number;
            switch (menuIndex){
                case 1:
                    System.out.print("请输入到达的车牌号：");
                    number = scanner.next();
                    inOutCar.inCar(number);
                    break;
                case 2:
                    System.out.print("请输入离开的车牌号：");
                    number = scanner.next();
                    inOutCar.outCar(number);
                    break;
                case 3:
                    inOutCar.parkPrint();
                    break;
                case 4:
                    inOutCar.waitPrint();
                    break;
                case 5:
                    System.out.println("现在的价格为："+getPrice()+"/秒");
                    System.out.print("请输入要修改为的价格：");
                    Integer newPrice = scanner.nextInt();
                    setPrice(newPrice);
                    System.out.println("修改成功");
                    break;
                case 0:
                    System.out.println("系统已退出");
                    return;
            }
        }
    }

    public static Integer getPrice() {
        return price;
    }

    public void setPrice(Integer price) {
        this.price = price;
    }

    public static void main(String[] args) {
        Parking parking = new Parking();
        parking.menu();
    }
}

InOutCar类

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * 实现各种进入出入停车场方法
 */
public class InOutCar {
    private InStack inCar;          //停车场
    private OutStack outCar;        //临时栈
    private Queue waitCar;          //候车区

    public InOutCar(){
        inCar = new InStack();
        outCar = new OutStack();
        waitCar = new Queue();
    }

    //停车到停车场
    public void inCar(String number){
        Car car = new Car(number);
        //判断停车场是否满了
        if (!inCar.isFull()){
            //没满，停车到停车场
            inCar.push(car);
            System.out.println("*********************");
            System.out.println("您的车牌号:"+inCar.getTop().getNumber());
            System.out.println("进入停车场时间:"+inCar.getTop().getInTime());
            System.out.println("*********************");
        }else{
            //满了，停车到候车区
            waitCar.enqueue(car);
            System.out.println("*********************");
            System.out.println("您的车牌号:" + car.getNumber());
            System.out.println("停车场已满，您现在在等待中，您的位置是第" + waitCar.getSize() + "个");
            System.out.println("*********************");
        }
    }

    //打印停车场信息
    public void parkPrint() {
        System.out.println("停车位     车牌号     到达时间");
        System.out.println("------------------------------");
        inCar.print();
    }

    //打印候车区信息
    public void waitPrint() {
        System.out.println("位置     车牌号");
        System.out.println("------------------------------");
        waitCar.print();
    }

    //退出停车场
    public void outCar(String number){
        try {
            while (!inCar.getTop().getNumber().equals(number)){
                //把之后进入的车辆先退出停车场
                outCar.push(inCar.popNoTime());
            }
            Car oCar = inCar.pop();
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date inTime = df.parse(oCar.getInTime());
            Date outTime = df.parse(oCar.getOutTime());

            long time = outTime.getTime() - inTime.getTime();

            System.out.println("*********************");
            System.out.println("你的车牌号："+oCar.getNumber());
            System.out.println("进入停车场时间："+oCar.getInTime());
            System.out.println("离开停车场时间："+oCar.getOutTime());
            System.out.println("需要交纳的费用："+time/1000 * Parking.getPrice()+"元");
            System.out.println("*********************");

            //把退出停车场的车加回去
            int length = outCar.getLength();
            for (int i = 0;i < length;i++){
                inCar.pushNoTime(outCar.pop());
            }

            //如果候车场有车，就安排进停车场
            if (waitCar.getSize() != 0){
                inCar.push(waitCar.dequeue());
            }
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

程序运行效果