用數組實現棧

用數組表示棧

選擇用數組表示棧內容必須預先估計棧的最大容量。在Java中，數組一旦創建，其大小是無法改變的，而數組設置過大可能會浪費大量內存，設置過小又可能會溢出。

所以我們希望能夠動態調整數組a[i]的大小，使得它既足以保存所有元素，又不至於浪費過多的空間。

 

首先，實現一個方法將棧移動到另一個大小不同的數組中。

private void resize(int max) {
        
        Item[] temp = (Item[]) new Object[max];
        for (int i = 0; i < N; i++) {
            temp[i] = a[i];
        }
        a = temp;
    }

 

 然后在push()中檢測數組是否太小。如果沒有多余的空間，就將數組的長度加倍。

 

 public void push(Item item) {

        if (N == a.length) resize(2*a.length);    
        a[N++] = item;                         

    }

 

 

類似的，在pop()中，先刪除棧頂元素，然后如果棧大小小於數組的四分之一就將數組的長度減半(這樣數組長度被減半之后約為半滿，在下次需要改變數組大小之前仍然能夠進行多次push()和pop()操作)。

 

 public Item pop() {
        
        Item item = a[--N];
        a[N] = null;                              //避免對象游離(見標注)
       
        if (N > 0 && N == a.length/4) resize(a.length/2);
        return item;
    }

 

 

 注：在對pop()的實現中，被彈出的元素的引用仍然存在於數組中。它永遠不會再被訪問了，但Java的垃圾回收集器無法知道這一點，除非該引用被覆蓋。這種情況(保存一個不需要的對象的引用)稱為游離。

在這里，只需將被彈出的數組元素的值設置為null即可。

 

 下面給出用數組表示棧的代碼實現：

 　　下壓(LIFO)棧(能夠動態調整數組大小的實現)：

 

public class ResizingArrayStack<Item> implements Iterable<Item> {
    private Item[] a;        
    private int N;           

    public ResizingArrayStack() {
        a = (Item[]) new Object[2];
        N = 0;
    }


    public boolean isEmpty() {
        return N == 0;
    }


    public int size() {
        return N;
    }


    private void resize(int capacity) {
        assert capacity >= N;
        Item[] temp = (Item[]) new Object[capacity];
        for (int i = 0; i < N; i++) {
            temp[i] = a[i];
        }
        a = temp;
    }


    public void push(Item item) {
        if (N == a.length) resize(2*a.length);    
        a[N++] = item;                            
    }

    public Item pop() {
        Item item = a[--N];
        a[N] = null;                              

        if (N > 0 && N == a.length/4) resize(a.length/2);
        return item;
    }


    public Item peek() {
        return a[--N];
    }


    public Iterator<Item> iterator() {
        return new ReverseArrayIterator();
    }

    private class ReverseArrayIterator implements Iterator<Item> {
        private int i;

        public ReverseArrayIterator() {
            i = N;
        }

        public boolean hasNext() {
            return i >= 0;
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }

        public Item next() {
            return a[--i];
        }
    }

}

 

 

用數組表示棧的優點：

      每項操作的用時都與集合大小無關；

      空間需求總是不超過集合大小乘以一個常數。

用數組表示棧的缺點：

      某些push()和pop()操作會調整數組的大小：這項操作的耗時和棧大小成正比。