队列

一、队列概述

队列是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。允许插入的一端称为队尾，允许删除的一端称为队头。

队列特点：先进先出(FIFO)

队列的结构：

二、Java实现顺序循环队列

引入两个指针，front指向队头，rear指向队尾元素的下一个位置，front等于rear时，是空队列。

a1，a2出列，再入队a5

这时，rear会移动到数组之外，如果再入队一个元素，就会产生数组越界的错误，但是数组下标为0和1的地方还是空闲的。这种现象叫做“假溢出”。我们可以让rear指向下标为0的位置，这样就可以解决rear指针的问题。

然后入队a6，将它放置于下标为0处，rear指向1，再入队a7，rear和front重合

那么，当front==rear是，我们如何判断此时的队列究竟是空还是满呢？我们可以让数组有一个空闲单元时就认为此时队列已满。

设队列大小为n，那么队列满的条件是(rear+1)%n==front,计算队列长度的公式为(rear-front+n)%n
右边队列(1+1)%5=2,取零余2。(1-2+5)%5=4,长度为4。

public class Queue {
    private Object array[];
    private int front, rear, size;
    private int maxsize;

    // 初始化一个长度为10的数组
    public Queue() {
        array = new Object[10];
        front = rear = size = 0;
        maxsize = 10;
    }

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

    public int size() {
        return size;
    }

    // 入队
    public void EnQueue(Object o) {
        if (((rear + 1) % maxsize == front))
            expand();
        array[rear] = o;
        rear = (rear + 1) % maxsize;
        size++;
    }

    // 出队
    public Object DeQueue() {
        Object obj = null;
        if (size == 0) {
            System.out.println("队列为空");
        } else {
            Object o = array[front];
            front = (front + 1) % maxsize;
            size--;
            obj = o;
        }
        return obj;
    }

    // 队首元素
    public Object front() {
        if (size == 0)
            System.out.println("队列为空");

        return array[front];
    }

    private void expand() {
        Object newArray[] = new Object[maxsize * 2];
        for (int i = 0; i < size; i++) {
            newArray[i] = array[(front + i) % maxsize];
        }
        array = newArray;
        front = 0;
        rear = size;
        maxsize = maxsize * 2;
    }

    public void clear() {
        for (int i = 0; i < maxsize; i++) {
            array[i] = null;
        }
        front = rear = size = 0;
    }

    public void show() {
        String str = "";
        for (int i = 0; i < size; i++) {
            str = str + array[(front + i) % maxsize];
            str = str + " ";
        }
        System.out.println(str);
    }

}

三、Java实现链式队列

public class Node {
    public Object data;
    public Node next;

    public Node() {
        this(null);
    }

    public Node(Object data) {
        this.data = data;
        this.next = null;
    }

}

public class LinkQueue {
    private Node front, rear;
    private int size;

    public LinkQueue() {
        front = rear = new Node();
        size = 0;
    }

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

    public int size() {
        return size;
    }

    public void EnQueue(Object o) {
        Node p = new Node(o);
        rear.next = p;
        rear = p;
        size++;
    }

    public Object DeQueue() {
        Node p = front.next;
        front.next = p.next;
        size--;
        return p.data;
    }

    public Object head() {
        return front.next.data;
    }

    public void clear() {
        front.next = null;
        rear = front;
        size = 0;
    }

    public void show() {
        StringBuilder sb = new StringBuilder();
        Node p = front;
        while ((p = p.next) != null) {
            sb.append(p.data);
            sb.append(" ");
        }
        System.out.println(sb);
    }

}