数组实现下压栈（可动态调整数组大小）

数组实现下压栈（可动态调整数组大小）

public class ResizingArrayStack<Item> implements Iterable<Item> {

    private Item[] a = (Item[])new Object[1];  //栈元素
    private int N = 0;    //元素数量

    /**
     * 栈是否为空
     * @return
     */
    public boolean isEmpty(){
        return N==0;
    }

    /**
     * 获取栈大小
     * @return
     */
    public int size(){
        return N;
    }

    /**
     * 调整栈的大小
     * @param max
     */
    private void resize(int max){
        Item[] temp = (Item[])new Object[max];
        for(int i =0;i<temp.length;i++){
            temp[i]=a[i];   //深拷贝
        }
        a=temp;
    }

    /**
     * 推入栈顶
     */
    public void push(Item item){
        if(N==a.length)
            resize(2*a.length);   //每次扩大至两倍
        a[N++]=item;
    }

    /**
     * 从栈顶删除元素返回
     * @return
     */
    public Item pop(){
     Item item = a[--N];
     a[N]=null;
     if(N>0&&N==a.length/4)  //缩小为二分之一
         resize(a.length/2);
     return item;
    }


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


    private class ReverseArrayIterator implements Iterator<Item>{
        //后进先出的迭代
        private int i = N;
        @Override
        public boolean hasNext() {
            return i>0;
        }

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

这里实现了后进先出的迭代。
这种数据类型保证了每种操作与栈的大小无关，并且栈的大小总是不会超过数据大小的一个常数倍（代码中该常数为2）。但是在进行某些push或者pop操作的时候，可能会改动栈的大小，因为改动时是采用拷贝的方式，就会耗费比较多的时间，其与栈的大小成正比。