我們知道，在數組中，若知道數據項的下標，便可立即訪問該數據項，或者通過順序搜索數據項，訪問到數組中的各個數據項。但是棧和隊列不同，它們的訪問是受限制的，即在特定時刻只有一個數據項可以被讀取或者被刪除。眾所周知，棧是先進后出，只能訪問棧頂的數據，隊列是先進先出，只能訪問頭部數據。這里不再贅述。

棧的主要機制可以用數組來實現，也可以用鏈表來實現，下面用數組來實現棧的基本操作：

數據項入棧和出棧的時間復雜度均為O(1)。這也就是說，棧操作所消耗的時間不依賴于棧中數據項的個數，因此操作時間很短。棧不需要比較和移動操作。

隊列也可以用數組來實現，不過這里有個問題，當數組下標滿了后就不能再添加了，但是數組前面由于已經刪除隊列頭的數據了，導致空。所以隊列我們可以用循環數組來實現，見下面的代碼：

public class RoundQueue {
    private long[] a;
    private int size;   //數組大小
    private int nItems; //實際存儲數量
    private int front;  //頭
    private int rear;   //尾
    public RoundQueue(int maxSize) {
        this.size = maxSize;
        a = new long[size];
        front = 0;
        rear = -1;
        nItems = 0;
    }
    public void insert(long value) {
        if(isFull()){
            System.out.println("隊列已滿");
            return;
        }
        rear = ++rear % size;
        a[rear] = value; //尾指針滿了就循環到0處,這句相當于下面注釋內容      
        nItems++;
/*        if(rear == size-1){
            rear = -1;
        }
        a[++rear] = value;
*/
    }
    public long remove() {
        if(isEmpty()) {
            System.out.println("隊列為空！");
            return 0;
        }
        nItems--;
        front = front % size;
        return a[front++];
    }
    public void display() {
        if(isEmpty()) {
            System.out.println("隊列為空！");
            return;
        }
        int item = front;
        for(int i = 0; i < nItems; i++) {
            System.out.print(a[item++ % size] + " ");
        }
        System.out.println("");
    }
    public long peek() {
        if(isEmpty()) {
            System.out.println("隊列為空！");
            return 0;
        }
        return a[front];
    }
    public boolean isFull() {
        return (nItems == size);
    }
    public boolean isEmpty() {
        return (nItems == 0);
    }
    public int size() {
        return nItems;
    }
}

和棧一樣，隊列中插入數據項和刪除數據項的時間復雜度均為O(1)。

還有個優先級隊列，優先級隊列是比棧和隊列更專用的數據結構。優先級隊列與上面普通的隊列相比，主要區別在于隊列中的元素是有序的，關鍵字最小（或者最大）的數據項總在隊頭。數據項插入的時候會按照順序插入到合適的位置以確保隊列的順序。優先級隊列的內部實現可以用數組或者一種特別的樹——堆來實現。

public class PriorityQueue {
    private long[] a;
    private int size;
    private int nItems;//元素個數
    public PriorityQueue(int maxSize) {
        size = maxSize;
        nItems = 0;
        a = new long[size];
    }
    public void insert(long value) {
        if(isFull()){
            System.out.println("隊列已滿！");
            return;
        }
        int j;
        if(nItems == 0) { //空隊列直接添加
            a[nItems++] = value;
        }
        else{//將數組中的數字依照下標按照從大到小排列
            for(j = nItems-1; j >= 0; j--) {
                if(value > a[j]){
                    a[j+1] = a[j];
                }
                else {
                    break;
                }
            }
            a[j+1] = value;
            nItems++;
        }
    }
    public long remove() {
        if(isEmpty()){
            System.out.println("隊列為空！");
            return 0;
        }
        return a[--nItems];
    }
    public long peekMin() {
        return a[nItems-1];
    }
    public boolean isFull() {
        return (nItems == size);
    }
    public boolean isEmpty() {
        return (nItems == 0);
    }
    public int size() {
        return nItems;
    }
    public void display() {
        for(int i = nItems-1; i >= 0; i--) {
            System.out.print(a[i] + " ");
        }
        System.out.println(" ");
    }
}

這里實現的優先級隊列中，插入操作需要 O(N) 的時間，而刪除操作則需要 O(1) 的時間。