《算法通关村——如何基于数组/链表实现栈》

1.基于数组

我们都知道数组的地址空间是固定的，若要扩容，需重新申请一片空间，再复制过去。同样的，在入栈之前，我们要判断空间是否够用，不用够扩容。假设top只想栈顶元素再上一格位置。

具体代码实现如下

    class MyStack <T>{
        private Object[] stack;
        private int top;
        MyStack (){
            stack = new Object [10];
        }
        public boolean isEmpty(){
            return top == 0;
        }
        public T peek(){
            T t = null;
            if (top > 0)
                t = (T)stack[top - 1];
            return t;
        }
        public void push(T t){
            expandCapacity(top + 1);
            stack[top] = t;
            top++;
        }
        public T pop(){
            T t = peek();
            if (top > 0) {
                stack[top - 1] = null;
                top--;
            }
            return t;
        }
        public void expandCapacity(int size){
            int len = stack.length;
            if(size > len){
                size = size*3/2+1;
                stack = Arrays.copyOf(stack,size);
            }
        }


    }

2.基于链表

链表的操作是根据头节点完成的，所以要初始化头节点head

class ListStack<T>{
    class Node<T>{
        public T t;
        public Node next;
    }
    public Node<T> head;
    ListStack(){
        head = null;
    }
    public void push(T t){
        if (t == null)
            throw new NullPointerException("参数不能为空");
        if (head == null){
            head = new Node<T>();
            head.t = t;
            head.next = null;
        }else {
            Node<T> temp = head;
            head = new Node<>();
            head.t = t;
            head.next = temp;
        }
    }
    public T pop(){
        if (head == null)
            return null;
        T t = head.t;
        return t;
    }
    public boolean isEmpty(){
        if (head == null) {
            return true;
        } else{
            return false;
        }
    }
}