链式队列（JAVA）

链式队列就是基于单链表实现的队列

直观的思路

队列的入队和出队对应单链表的添加一侧节点，删除另一侧节点
在链式栈（JAVA）中有一个关于使用单链表的结论，单链表的头或者尾添加节点都简单，但就删除节点来看，在头部操作要优于在尾部操作。
所以这已经是直观思路的升级版了，那就是使用单链表的头作为出队位置，使用单链表的尾作为入队位置。
为降低获取单链表尾节点的过程，需要将单链表的实现代码稍作改造

单链表代码

public class SinglyLinkedList2<T> {

    private SinglyLinkedNode<T> header;

    private SinglyLinkedNode<T> tail;

    private int size;

    public SinglyLinkedNode<T> getHeader() {
        return header;
    }

    public SinglyLinkedNode<T> getTail() {
        return tail;
    }

    public int getSize() {
        return size;
    }

    /**
     * 从尾加元素
     *
     * @param element
     * @return
     */
    public SinglyLinkedNode<T> addToTail(T element) {
        SinglyLinkedNode<T> newNode = new SinglyLinkedNode<>(element);
        if (this.tail == null) {
            // 原为空
            this.header = this.tail = newNode;
        } else {
            this.tail.setNext(newNode);
            this.tail = newNode;
        }
        this.size++;
        return newNode;
    }

    /**
     * 从头删元素
     *
     * @return
     */
    public SinglyLinkedNode<T> dropFromHeader() {
        if (this.header == null) {
            System.out.println("empty linkedList");
            return null;
        }
        SinglyLinkedNode<T> temp = this.header;
        SinglyLinkedNode<T> next = this.header.getNext();
        if (next == null) {
            // 删完就空了
            this.header = this.tail = next;
        } else {
            this.header = next;
        }
        this.size--;
        return temp;
    }

    @Override
    public String toString() {
        SinglyLinkedNode<T> current = this.header;
        StringBuilder stringBuilder = new StringBuilder("linkedList[");
        while (current != null) {
            stringBuilder.append(current.getData()).append(", ");
            current = current.getNext();
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }

}

主要改变时添加了tail字段，链表添加节点只保留从尾添加，链表删除节点只保留从头删除。

链式队列

public class LinkedQueue<T> {

    private SinglyLinkedList2<T> linkedList;

    public LinkedQueue() {
        this.linkedList = new SinglyLinkedList2<>();
    }

    public boolean enqueue(T element) {
        linkedList.addToTail(element);
        return true;
    }

    public T dequeue() {
        SinglyLinkedNode<T> node = linkedList.dropFromHeader();
        return node == null ? null : node.getData();
    }

    @Override
    public String toString() {
        return linkedList.toString();
    }

    public static void main(String[] args) {
        LinkedQueue<String> queue = new LinkedQueue<>();
        System.out.println(queue);
        queue.enqueue("A");
        queue.enqueue("B");
        queue.enqueue("C");
        queue.enqueue("D");
        System.out.println(queue);
        queue.dequeue();
        System.out.println(queue);
        queue.dequeue();
        System.out.println(queue);
        queue.enqueue("E");
        System.out.println(queue);
        queue.enqueue("F");
        System.out.println(queue);
        queue.enqueue("G");
        System.out.println(queue);
        queue.enqueue("H");
        System.out.println(queue);
        queue.dequeue();
        queue.dequeue();
        queue.dequeue();
        queue.dequeue();
        queue.dequeue();
        queue.dequeue();
        queue.dequeue();
        queue.enqueue("I");
        System.out.println(queue);
    }

}

执行结果

linkedList[]
linkedList[A, B, C, D, ]
linkedList[B, C, D, ]
linkedList[C, D, ]
linkedList[C, D, E, ]
linkedList[C, D, E, F, ]
linkedList[C, D, E, F, G, ]
linkedList[C, D, E, F, G, H, ]
empty linkedList
linkedList[I, ]