基于双链表 实现Java Queue队列

除了可以通过一维数组，单链表实现queue队列，还可以通过双链表实现queue队列。

在基于NLNode类实现双向链表的时候，为了使编程更加简洁，通常我们都要在最前端和最后端各设置一个哑元节点（ Dummy node ）。这两个节点分别称作头节点（ Header node ）和尾节点（ Trailer node） ㈠，起哨兵（ Sentinel）的作用。也就是说，它们并不存储任何实质的数据对象，头（尾）节点的next（ prev）引用指向首（末）节点，而prev（next）引用为空。如此构成的双向链表结构，如下代码示：

Java代码：

DoubleNode 类：

package com.doub.list;

/**
 * 
 * @author gannyee
 *
 */
public class DoubleNode {

    //Declared element
    private Object element;
    //Declared prior
    private DoubleNode prior;
    //Declared next
    private DoubleNode next;

    //Constructor 
    public DoubleNode(){
        this(null,null,null);
    }

    public DoubleNode(DoubleNode prior,Object element, DoubleNode next){
        this.prior = prior;
        this.element = element;
        this.next = next;
    }
    //Get element
    public Object getElement() {
        return element;
    }

    //Set element
    public void setElement(Object element) {
        this.element = element;
    }

    //Get prior
    public DoubleNode getPrior() {
        return prior;
    }

    //Set prior
    public void setPrior(DoubleNode prior) {
        this.prior = prior;
    }

    //Get next
    public DoubleNode getNext() {
        return next;
    }

    //Set next
    public void setNext(DoubleNode next) {
        this.next = next;
    }

}

DoubleListQueue 类：

package com.doub.list;

import java.util.Arrays;

import com.queue.ExceptionQueueEmpty;

public class DoubleListQueue {

    // Declared head
    private static DoubleNode head;
    // Declared rear
    private static DoubleNode rear;
    // Declared size;
    private static int size;
    //Declared length
    private static int length;
    // Constructor
    public DoubleListQueue() {
        //initialize  
        head = new DoubleNode();
        rear = new DoubleNode();

        head.setNext(rear);
        head.setPrior(null);
        rear.setNext(null);
        rear.setPrior(head);
        this.size = this.length = 0;
    }

    // Get size
    public int getSize() {
        return size;
    }

    //Get length
    public int length(){
        return length;
    }

    // Is empty
    public boolean isEmpty() {
        return size == 0;
    }

    // Insert element in first position
    public void insertFirst(Object element) {
        DoubleNode newNode = new DoubleNode(head,element,head.getNext());
        head.getNext().setPrior(newNode);
        head.setNext(newNode);
        size ++;
        length = size;
    }

    // Insert element in last position
    public void insertLast(Object element) {
        DoubleNode newNode = new DoubleNode(rear.getPrior(),element,rear);
        rear.getPrior().setNext(newNode);
        rear.setPrior(newNode);
        size ++;
        length = size;
    }

    // Remove element from first position
    public void removeFirst() throws ExceptionQueueEmpty{
        if(isEmpty())
            throw new ExceptionQueueEmpty("Queue is empty");
        head.getNext().getNext().setPrior(head);
        head.setNext(head.getNext().getNext());
        size --;
    }

    // Remove element from last position
    public void removeLast() throws ExceptionQueueEmpty{
        if(isEmpty())
            throw new ExceptionQueueEmpty("Queue is empty");
        rear.getPrior().getPrior().setNext(rear);
        rear.setPrior(rear.getPrior().getPrior());
        size --;
    }

    // Get first node but not isn't deletion
    public Object getFirst() throws ExceptionQueueEmpty{
        if(isEmpty())
            throw new ExceptionQueueEmpty("Queue is empty");
        return head.getNext().getElement();
    }

    // Get last node but not isn't deletion
    public Object getLast() throws ExceptionQueueEmpty{
        if(isEmpty())
            throw new ExceptionQueueEmpty("Queue is empty");
        return rear.getPrior().getElement();
    }

    //Get all element
    public void getAllElements(){
        Object[] array = new Object[getSize()];

        DoubleNode travelNode = new DoubleNode();
        travelNode = head.getNext();
        for(int i = 0; travelNode != rear;i ++){
            array[i] = travelNode.getElement();
            travelNode = travelNode.getNext();
        }
        System.out.println("All elements are: " + Arrays.toString(array));
    }
}

DoubleListQueueTest 类：

package com.doub.list;

import com.queue.ExceptionQueueEmpty;

/**
 * 
 * @author gannyee
 *
 */
public class DoubleListQueueTest {

    public static void main(String[] args) throws ExceptionQueueEmpty {
        DoubleListQueue dlq = new DoubleListQueue();

        System.out.println("Size: " + dlq.getSize());
        System.out.println("Is empty? " + dlq.isEmpty());

        for(int i = 0;i < 6;i ++){
            dlq.insertFirst(i);
        }

        System.out.println("Size: " + dlq.getSize());
        System.out.println("Is empty? " + dlq.isEmpty());
        dlq.getAllElements();
        System.out.println(dlq.getFirst());
        System.out.println(dlq.getLast());

        for(int i = 0;i < 6;i ++){
            dlq.insertLast(i + 1);
        }

        System.out.println("Size: " + dlq.getSize());
        System.out.println("Is empty? " + dlq.isEmpty());
        dlq.getAllElements();
        System.out.println(dlq.getFirst());
        System.out.println(dlq.getLast());

        for(int i = 0;i < 6;i ++){
            dlq.removeFirst();
        }

        System.out.println("Size: " + dlq.getSize());
        System.out.println("Is empty? " + dlq.isEmpty());
        dlq.getAllElements();
        System.out.println(dlq.getFirst());
        System.out.println(dlq.getLast());

        for(int i = 0;i < 6;i ++){
            dlq.removeLast();
        }

        System.out.println("Size: " + dlq.getSize());
        System.out.println("Is empty? " + dlq.isEmpty());
        dlq.getAllElements();
    }

}

测试结果：

Size: 0
Is empty? true
Size: 6
Is empty? false
All elements are: [5, 4, 3, 2, 1, 0]
5
0
Size: 12
Is empty? false
All elements are: [5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5, 6]
5
6
Size: 6
Is empty? false
All elements are: [1, 2, 3, 4, 5, 6]
1
6
Size: 0
Is empty? true
All elements are: []

参考文献：数据结构与算法（ Java 描述）邓俊辉 著