用数组实现栈

用数组表示栈

选择用数组表示栈内容必须预先估计栈的最大容量。在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()操作会调整数组的大小：这项操作的耗时和栈大小成正比。