队列 04 基于链表的队列

• 基于链表的队列不是指的底层维护了一个链表的队列，更简单的，是实现了Queue接口的链表；
• 区别于普通的LinkedList，LinkedListQueue中存在2个分别指向头节点和尾节点的指针head和tail，入队（插入节点）只在tail节点之后，出队（删除节点）只删除head节点；

public class LinkedListQueue<E> implements Queue<E> {

    private class Node{
        public E e;
        public Node next;

        public Node(E e, Node next){
            this.e = e;
            this.next = next;
        }

        public Node(E e){
            this(e, null);
        }

        public Node(){
            this(null, null);
        }

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

    private Node head, tail;
    private int size;

    public LinkedListQueue(){
        head = null;
        tail = null;
        size = 0;
    }

    @Override
    public int getSize(){
        return size;
    }

    @Override
    public boolean isEmpty(){
        return size == 0;
    }

}

入队 - void enqueue(E e)

• 如果tail == null，那么说明链表中没有节点，此时head也为null；
• 如果tail != null，只需在tail后链上入队的节点，然后让tail重新指向队尾节点；

@Override
public void enqueue(E e){
    if(tail == null){
        tail = new Node(e);
        head = tail;
    }
    else{
        tail.next = new Node(e);
        tail = tail.next;
    }
    size ++;
}

出队 - E dequeue()

• 队列为空就没法出队了；
• 只需要出head指向的节点的值，并删除head指向的节点即可；
• 如果出队完队列中没元素了，即head == null了，那么让tail也指向null （被删除的队列中的唯一元素，既没有指向别人的引用，也没有引用指向它，方可被GC回收）；

@Override
public E dequeue(){
    if(isEmpty())
        throw new IllegalArgumentException("Cannot dequeue from an empty queue.");

    Node retNode = head;
    head = head.next;
    retNode.next = null;
    if(head == null)
        tail = null;
    size --;
    return retNode.e;
}

看一眼队首的元素 - E getFront()

• return head.e;

@Override
public E getFront(){
    if(isEmpty())
        throw new IllegalArgumentException("Queue is empty.");
    return head.e;
}

String toString()

@Override
public String toString(){
    StringBuilder res = new StringBuilder();
    res.append("Queue: front ");

    Node cur = head;
    while(cur != null) {
        res.append(cur + "->");
        cur = cur.next;
    }
    res.append("NULL tail");
    return res.toString();
}

• 测试代码

public static void main(String[] args){

    LinkedListQueue<Integer> queue = new LinkedListQueue<>();
    for(int i = 0 ; i < 10 ; i ++){
        queue.enqueue(i);
        System.out.println(queue);

        if(i % 3 == 2){
            queue.dequeue();
            System.out.println(queue);
        }
    }
}

输出：

Queue: front 0->NULL tail
Queue: front 0->1->NULL tail
Queue: front 0->1->2->NULL tail
Queue: front 1->2->NULL tail
Queue: front 1->2->3->NULL tail
Queue: front 1->2->3->4->NULL tail
Queue: front 1->2->3->4->5->NULL tail
Queue: front 2->3->4->5->NULL tail
Queue: front 2->3->4->5->6->NULL tail
Queue: front 2->3->4->5->6->7->NULL tail
Queue: front 2->3->4->5->6->7->8->NULL tail
Queue: front 3->4->5->6->7->8->NULL tail
Queue: front 3->4->5->6->7->8->9->NULL tail