算法通关村—如何基于数组实现栈(与JDK源码对比)

        栈和队列是比较特殊的线性表，又称之为访问受限的线性表。栈是很多表达式、符号等运算的基础，也是递归的底层实现。理论上递归能做的题目栈都可以，只是有些问题用栈会非常复杂。
        栈底层实现仍然是链表或者顺序表，栈与线性表的最大区别是数据的存取的操作被限制了，其插入和删除操作只允许在线性表的一端进行。一般而言，把允许操作的一端称为栈顶(Top)，不可操作的一端称为栈底(Bottom)，同时把插入元素的操作称为入栈(Push),删除元素的操作称为出栈(Pop)。若栈中没有任何元素，则称为空栈，栈的结构如下图：

 java的util中就提供了栈Stack类，使用不复杂，看一个例子就够了：

 public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        System.out.println("栈顶元素为：" + stack.peek());
        while (!stack.empty()) {
            //只显示没出栈
            System.out.println(stack.peek());
            //出栈并且显示
            System.out.println(stack.pop());
        }
    }

栈的常用操作主要有：

• push(E):增加一个元素E
• pop():弹出元素E
• peek():显示栈顶元素，但是不出栈
• empty():判断栈是否为空

我们在设计自己的栈的时候，不管用数组还是链表，都要实现上面几个方法。

public class MyStack<T> {
    private Object[] stack;
    private int pos;

    public MyStack(int initSize) {
        if (initSize < 1) {
            throw new IllegalArgumentException("initSize 不能小于1");
        }
        stack = new Object[initSize];
        pos = -1;
    }

    public MyStack() {
        stack = new Object[10];
        pos = -1;
    }

    public void push(T element) {
        stack[++pos] = element;
    }

    public T pop() {
        return (T) stack[pos--];
    }

    public T peek() {
        return (T) stack[pos];
    }

    public boolean empty() {
        return pos == -1;
    }
}

其中pos指针永远指向当前的栈顶元素

但是，这个简单的例子中可以看出来，这个栈的容量是固定不变的，假如有11个元素呢？

这就需要做到栈的扩容

    public boolean extendStack() {
        //这里直接简单扩大一倍，具体可自行选择
        stack = Arrays.copyOf(stack, stack.length * 2);
        return stack.length > pos + 1;
    }

那需要在什么时候进行扩容呢？是否就是每次添加元素的时候才会需要扩容，以此我们可以修改push的代码。

public void push(T element) {
        //这里选择在满的时候再扩容，也可以选择只剩下一定容量的时候再选择扩容
        if (pos == stack.length - 1) {
            extendStack();
        }
        stack[++pos] = element;
    }

这样就实现了自动扩容。

接下来，我们可以看看JDK中的Stack实现，下面就是去掉文档注释后的JDK源码。

public class Stack<E> extends Vector<E> {

    public Stack() {
    }


    public E push(E item) {
        addElement(item);

        return item;
    }


    public synchronized E pop() {
        E obj;
        int len = size();

        obj = peek();
        removeElementAt(len - 1);

        return obj;
    }


    public synchronized E peek() {
        int len = size();

        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }

    public boolean empty() {
        return size() == 0;
    }


    public synchronized int search(Object o) {
        int i = lastIndexOf(o);

        if (i >= 0) {
            return size() - i;
        }
        return -1;
    }

}

我们以push为例，点进去看看。

    public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = obj;
    }

addElement方法被synchronized包裹，可以得出他是线程安全的方法，

ensureCapacityHelper就是保障Stack的容量的一个方法，实现自动扩容，基本就是具体扩容规则的一些实现，不再深究。

    private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    } 
   private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

从push源码可以看出，JDK Stack实现基本与我们自行实现的Stack基本相似，在细节上有些区别，大家可以去试试实现一下JDK中的Stack。