数据结构学习dayFour（一）

* dayFour（一）
* 队列
* 和栈相反，队列是一种先进先出（first in first out，缩写为FIFO）的线性表。
* 它只允许在表的一端进行插入，而在另一端删除元素。
* 允许插入的一端叫做队尾，允许删除的一端称为队头。
* 随着队头元素不断地移除，数组前面空出的位置会越来越多，
* 当队尾指针移到最后的位置时，即使队列没有满，我们也不能再插入新的数据项。
* 可以使用循环队列来解决上述问题。
* 虽然在存储上是线形的，但是在逻辑上它是一个首尾衔接的环形。
* 以下为队列的顺序表示形式的实现。

public class Queue<E> {
    private Object[] data;

    //最大容量
    private int maxSize;

    //队头指针
    private int front;

    //队尾指针
    private int rear;

    /**
     * 初始化队列
     *
     * @param maxSize 队列最大长度
     */
    public Queue(int maxSize) {
        if (maxSize <= 0) {
            throw new RuntimeException("初始化大小不能小于0");
        } else {
            this.maxSize = maxSize;
            this.data = new Object[maxSize];
            this.front = 0;
            this.rear = 0;
        }
    }

    /**
     * 返回队列实际长度
     *
     * @return 队列实际长度
     */
    public int queueLength() {
        return (rear - front + maxSize) % maxSize;
    }

    /**
     * 元素进入队列
     * @param e 要入队的元素
     */
    public void enQueue(E e) {
        if ((rear + 1) % maxSize == front) {
            throw new RuntimeException("队列满，无法插入");
        } else {
            data[rear] = e;
            rear = (rear + 1) % maxSize;
        }
    }

    /**
     * 元素出队
     * @return 出队的元素
     */
    public E deQueue() {
        if (front == rear) {
            throw new RuntimeException("队列空，无法移除");
        } else {
            E e = (E) data[front];
            front = (front + 1) % maxSize;
            return e;
        }
    }

    /**
     * 判断队空
     * @return true：空，false：不空
     */
    public boolean isNull(){
        return front == rear;
    }

    /**
     * 判断队满
     * @return true：队满，false：不满
     */
    public boolean isFull(){
        return (rear + 1) % maxSize == front;
    }

    /**
     * 初始化队列
     */
    public void initQueue(){
        front = 0;
        rear = 0;
    }
}

转载于:https://my.oschina.net/u/3970508/blog/3033796