資料結構之佇列結構

佇列：佇列結構是一種線性結構。從資料的儲存結構來進一步劃分，佇列包括兩類：
          順序佇列結構：使用一組地址連續的記憶體單元依次儲存佇列中的資料；
          鏈式佇列結構：使用連結串列形式儲存佇列中各元素的值；

在佇列結構中允許對兩端進行操作，但是兩端的操作不同。在表的一端只能進行刪除操作，稱為隊頭；

在表的另一端只能進行插入操作，稱為隊尾。若隊伍中沒有資料元素，則稱為空佇列。

佇列是按照“先進先出”的原則處理結點資料的。

  1 Java實現的佇列：
  2 
  3 /**
  4  * 佇列: 先進先出,後進後出的線性表. head端刪除;tail端插入.
  5  * 
  6  * @see java.util.ArrayDeque
  7  */
  8 public class xQueue<E> {
  9 
 10     Object[] elements;
 11 
 12     int head; // 佇列的頭部,位置固定.
 13 
 14     int tail; // 佇列的尾部
 15 
 16     private
 
 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
 17 
 18     private static final int MAX_CAPACITY = 1 << 30;
 19 
 20     /** 構造 */
 21     public xQueue() {
 22         elements = new Object[DEFAULT_INITIAL_CAPACITY];
 23     }
 24 
 25     /** 構造 */
 26     public xQueue(Collection<? extends
 
 E> c) {
 27         elements = new Object[calculateSize(c.size())];
 28         addAll(c);
 29     }
 30 
 31     /* 計算Queue大小 */
 32     private int calculateSize(int capacity) {
 33         if (capacity < DEFAULT_INITIAL_CAPACITY)
 34             return DEFAULT_INITIAL_CAPACITY;
 35         int c = (int) Math.pow(2, capacity >> 2);
 36         return Math.min(c, MAX_CAPACITY);
 37     }
 38 
 39     /* 擴容 */
 40     private void doubleCapacity() {
 41         int b = elements.length;
 42         int newCapacity = Math.min(b << 1, MAX_CAPACITY);
 43         if (newCapacity < 0)
 44             throw new IllegalStateException("xQueue too big");
 45         Object[] o = new Object[newCapacity];
 46         System.arraycopy(elements, 0, o, 0, b);
 47         elements = o;
 48     }
 49 
 50     /**
 51      * 插入若干個元素
 52      * 
 53      * @param c
 54      * @return
 55      */
 56     public boolean addAll(Collection<? extends E> c) {
 57         boolean modified = false;
 58         for (E e : c)
 59             if (add(e))
 60                 modified = true;
 61         return modified;
 62     }
 63 
 64     /**
 65      * 將指定的元素插入佇列,成功則返回true.
 66      * 
 67      * @param e
 68      * @return
 69      */
 70     public boolean add(E e) {
 71         Objects.requireNonNull(e);
 72         int l = elements.length;
 73         if (tail < l) {
 74             elements[tail] = e;
 75             tail++;
 76         } else if (tail >= l) {
 77             doubleCapacity(); // 擴容
 78             elements[tail] = e;
 79             tail++;
 80         }
 81         return true;
 82     }
 83 
 84     /**
 85      * 獲取但不移除佇列的頭.若佇列為空,則丟擲異常.
 86      * 
 87      * @throws NoSuchElementException
 88      * @return
 89      */
 90     public E getHead() {
 91         @SuppressWarnings("unchecked")
 92         E result = (E) elements[head];
 93         if (result == null)
 94             throw new NoSuchElementException();
 95         return result;
 96     }
 97 
 98     /**
 99      * 獲取並移除佇列的頭
100      * 
101      * @return
102      */
103     public E remove() {
104         int h = head;
105         @SuppressWarnings("unchecked")
106         E result = (E) elements[h];
107         if (result == null)
108             return null;
109         elements[h] = null;
110         int l = elements.length;
111         Object[] o = new Object[l];
112         System.arraycopy(elements, h + 1, o, 0, l - 1); // 移除頭後,所有元素都要向前移動,保證頭永遠是0.
113         elements = o;
114         tail--;
115         return result;
116     }
117 
118     /**
119      * 獲取佇列長度
120      * 
121      * @return
122      */
123     public int length() {
124         return (tail - head) & (elements.length - 1);
125     }
126 
127     /**
128      * 返回queue物件字串表示
129      */
130     public String toString() {
131         if (length() == 0)
132             return "[]";
133         Object[] o = Arrays.copyOf(elements, length());
134         return Arrays.toString(o);
135     }
136 
137 }