链表栈 顺序栈(底层是数组实现的)

链表栈 

public class StackBasedOnLinkedList {

    private Node top = null;


    private static class Node {
        int data;
        Node next;

        public Node(int data, Node next) {
            this.data = data;
            this.next = next;
        }

        public int getData() {
            return data;
        }
    }

    public void push(int value) {
        Node newNode = new Node(value, null);
        if (top == null) {
            top = newNode;
        } else {
            newNode.next = top;
            top = newNode;
        }
    }

    public int pop() {
        if (top == null) return -1;//表示栈中没有数据了
        int value = top.getData();
        top = top.next;
        return value;
    }

    public void printAll() {
        Node p = top;
        while (p != null) {
            System.out.println(p.data + " ");
            p = p.next;
        }
        System.out.println();
    }

}

数组栈

public class ArrayStack {
    private String[] items;
    private int count;
    private int n;

    public ArrayStack(int n){
        this.items = new String[n];
        this.n = n;
        this.count = 0;
    }

    public boolean push(String item){
        if(count == n) return false;
        items[count++] = item;
        return true;
    }

    public String pop(){
        if(count == 0) return null;

        String temp = items[count--];
        return temp;
    }


}

不管是顺序栈还是链式栈，我们存储数据只需要一个大小为 n 的数组就够了。在入栈和出栈过程中，只需要一两个临时变量存储空间，所以空间复杂度是 O(1) 。
注意，这里存储数据需要一个大小为 n 的数组，并不是说空间复杂度就是 O(n) 。因为，这 n 个空间是必须的，无法省掉。所以我们说空间复杂度的时候，是指除了
原本的数据存储空间外，算法运行还需要额外的存储空间。

空间复杂度分析是不是很简单？时间复杂度也不难。不管是顺序栈还是链式栈，入栈、出栈只涉及栈顶个别数据的操作，所以时间复杂度都是 O(1) 。