Java隊列存儲結構及實現

一、隊列（Queue）

隊列是一種特殊的線性表，它只允許在表的前段（front）進行刪除操作，只允許在表的后端（rear）進行插入操作。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。

對於一個隊列來說，每個元素總是從隊列的rear端進入隊列，然后等待該元素之前的所有元素出隊之后，當前元素才能出對，遵循先進先出（FIFO）原則。

如果隊列中不包含任何元素，該隊列就被稱為空隊列。

Java提供了一個Queue接口，並為該接口提供了眾多的實現類：ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue、PriorityQueue、ConcurrentLinkedQueue和SynchronousQueue。

其中常用的是：ArrayBlockingQueue、LinkedBlockingQueue和CurrentLinkedQueue，它們都是線程安全的隊列。LinkedBlockingQueue隊列的吞吐量通常比ArrayBlockingQueue隊列高，但在大多數並發應用程序中，LinkedBlockingQueue的性能要低。

除了LinkedBlockingQueue隊列之外，JDK還提供了另外一種鏈隊列ConcurrentLinkedQueue，它基於一種先進的、無等待（wait-free）隊列算法實現。

二、順序隊列存儲結構的實現

package com.ietree.basic.datastructure.queue;

import java.util.Arrays;

/**
 * Created by ietree
 * 2017/4/29
 */
public class SequenceQueue<T> {

    private int DEFAULT_SIZE = 10;
    // 保存數組的長度
    private int capacity;
    // 定義一個數組用於保存順序隊列的元素
    private Object[] elementData;
    // 保存順序隊列中元素的當前個數
    private int front = 0;
    private int rear = 0;

    // 以默認數組長度創建空順序隊列
    public SequenceQueue() {

        capacity = DEFAULT_SIZE;
        elementData = new Object[capacity];

    }

    // 以一個初始化元素來創建順序隊列
    public SequenceQueue(T element) {

        this();
        elementData[0] = element;
        rear++;

    }

    /**
     * 以指定長度的數組來創建順序線性表
     *
     * @param element  指定順序隊列中第一個元素
     * @param initSize 指定順序隊列底層數組的長度
     */
    public SequenceQueue(T element, int initSize) {

        this.capacity = initSize;
        elementData = new Object[capacity];
        elementData[0] = element;
        rear++;
    }

    /**
     * 獲取順序隊列的大小
     *
     * @return 順序隊列的大小值
     */
    public int length() {

        return rear - front;

    }

    /**
     * 插入隊列
     *
     * @param element 入隊列的元素
     */
    public void add(T element) {

        if (rear > capacity - 1) {
            throw new IndexOutOfBoundsException("隊列已滿異常");
        }
        elementData[rear++] = element;

    }

    /**
     * 移除隊列
     *
     * @return 出隊列的元素
     */
    public T remove() {

        if (empty()) {
            throw new IndexOutOfBoundsException("空隊列異常");
        }

        // 保留隊列的rear端的元素的值
        T oldValue = (T) elementData[front];
        // 釋放隊列頂元素
        elementData[front++] = null;
        return oldValue;

    }

    // 返回隊列頂元素，但不刪除隊列頂元素
    public T element() {

        if (empty()) {
            throw new IndexOutOfBoundsException("空隊列異常");
        }
        return (T) elementData[front];

    }

    // 判斷順序隊列是否為空
    public boolean empty() {

        return rear == front;

    }

    // 清空順序隊列
    public void clear() {

        // 將底層數組所有元素賦值為null
        Arrays.fill(elementData, null);
        front = 0;
        rear = 0;

    }

    public String toString() {

        if (empty()) {

            return "[]";

        } else {

            StringBuilder sb = new StringBuilder("[");
            for (int i = front; i < rear; i++) {
                sb.append(elementData[i].toString() + ", ");
            }
            int len = sb.length();
            return sb.delete(len - 2, len).append("]").toString();
        }

    }

}

測試類：

package com.ietree.basic.datastructure.queue;

/**
 * Created by ietree
 * 2017/4/30
 */
public class SequenceQueueTest {

    public static void main(String[] args) {

        SequenceQueue<String> queue = new SequenceQueue<String>();
        // 依次將4個元素加入到隊列中
        queue.add("aaaa");
        queue.add("bbbb");
        queue.add("cccc");
        queue.add("dddd");
        System.out.println(queue);

        System.out.println("訪問隊列的front端元素：" + queue.element());

        System.out.println("第一次彈出隊列的front端元素：" + queue.remove());

        System.out.println("第二次彈出隊列的front端元素：" + queue.remove());

        System.out.println("兩次remove之后的隊列：" + queue);
    }

}

程序輸出：

[dddd, cccc, bbbb, aaaa]
訪問棧頂元素：dddd
第一次彈出棧頂元素：dddd
第二次彈出棧頂元素：cccc
兩次pop之后的棧：[bbbb, aaaa]

三、隊列的鏈式存儲結構實現

package com.ietree.basic.datastructure.queue;

/**
 * Created by ietree
 * 2017/4/30
 */
public class LinkQueue<T> {

    // 定義一個內部類Node，Node實例代表鏈隊列的節點
    private class Node {

        // 保存節點的數據
        private T data;
        // 指向下個節點的引用
        private Node next;

        // 無參構造器
        public Node() {
        }

        // 初始化全部屬性的構造器
        public Node(T data, Node next) {

            this.data = data;
            this.next = next;

        }

    }

    // 保存該鏈隊列的頭節點
    private Node front;
    // 保存該鏈隊列的尾節點
    private Node rear;
    // 保存該鏈隊列中已包含的節點數
    private int size;

    // 創建空鏈隊列
    public LinkQueue() {
        // 空鏈隊列，front和rear的值都為null
        front = null;
        rear = null;
    }

    // 以指定數據元素來創建鏈隊列，該鏈隊列只有一個元素
    public LinkQueue(T element) {

        front = new Node(element, null);
        // 只有一個節點，front、rear都是指向該節點
        rear = front;
        size++;

    }

    // 返回鏈隊列的長度
    public int length() {

        return size;

    }

    // 將新元素加入隊列
    public void add(T element) {
        // 如果該鏈隊列還是空鏈隊列
        if (front == null) {
            front = new Node(element, null);
            // 只有一個節點，front、rear都是指向該節點
            rear = front;
        } else {
            // 創建新節點
            Node newNode = new Node(element, null);
            // 讓尾節點的next指向新增的節點
            rear.next = newNode;
            rear = newNode;
        }
        size++;
    }

    // 刪除隊列front端的元素
    public T remove() {

        Node oldfront = front;
        // 讓front引用指向原隊列頂元素的下一個元素
        front = front.next;
        // 釋放原隊列頂元素的next引用
        oldfront.next = null;
        size--;
        return oldfront.data;

    }

    // 訪問隊列頂元素，但不刪除隊列頂元素
    public T element() {

        return rear.data;

    }

    // 判斷鏈隊列是否為空隊列
    public boolean empty() {

        return size == 0;

    }

    // 請空鏈隊列
    public void clear() {
        // 將front、rear兩個節點賦為null
        front = null;
        rear = null;
        size = 0;
    }

    public String toString() {

        // 鏈隊列為空隊列時
        if (empty()) {
            return "[]";
        } else {
            StringBuilder sb = new StringBuilder("[");
            for (Node current = front; current != null; current = current.next) {
                sb.append(current.data.toString() + ", ");
            }
            int len = sb.length();
            return sb.delete(len - 2, len).append("]").toString();
        }

    }

}

測試類：

package com.ietree.basic.datastructure.queue;

/**
 * Created by ietree
 * 2017/4/30
 */
public class LinkQueueTest {

    public static void main(String[] args) {

        LinkQueue<String> queue = new LinkQueue<String>("aaaa");
        // 依次將4個元素加入到隊列中
        queue.add("bbbb");
        queue.add("cccc");
        queue.add("dddd");
        System.out.println(queue);

        // 刪除一個元素后
        queue.remove();
        System.out.println("刪除一個元素后的隊列：" + queue);

        // 再添加一個元素
        queue.add("eeee");
        System.out.println("再次添加元素后的隊列：" + queue);

    }

}

程序輸出：

[aaaa, bbbb, cccc, dddd]
刪除一個元素后的隊列：[bbbb, cccc, dddd]
再次添加元素后的隊列：[bbbb, cccc, dddd, eeee]