java实现栈

栈的概念：栈是一种线性数据结构，栈中的元素只能先入后出(First In Last Out，简称FILO)。最早进入栈中的元素存放的位置叫栈底，最后进入的元素存放的位置叫栈顶。元素进入到栈中的过程叫做压栈，从栈中出去的过程叫做弹栈。栈既可以用数组实现，也可以用链表实现。数组实现的叫做顺序栈或静态栈，链表实现的叫做链式或者动态栈。

静态栈代码实现

public class ArrayStack<T> {
    private final T[] array;
    private final int length;
    private int size = 0;

    public ArrayStack(int length) {
        this.length = length;
        this.array = (T[]) new Object[length];
    }

    public ArrayStack(){
        this(6);
    }

    /**
     * 入栈
     * @param param 入栈的数据
     */
    public void inStack(T param){
        if (size>length-1){
            throw new RuntimeException("The stack is full");
        }
        array[size] = param;
        size++;
    }

    /**
     * 出栈
     * @return 出栈的数据
     */
    public T outStack(){
        if (size < 0){
            throw new RuntimeException("The stack is null");
        }
        T temp = array[size-1];
        array[size-1] = null;
        size--;
        return temp;
    }


    public static void main(String[] args) {
        ArrayStack<String> arrayStack = new ArrayStack<>(5);
        arrayStack.inStack("q");
        arrayStack.inStack("w");
        arrayStack.inStack("e");
        arrayStack.inStack("r");
        arrayStack.inStack("t");

        System.out.println(arrayStack.outStack());
        System.out.println(arrayStack.outStack());
        System.out.println(arrayStack.outStack());
        System.out.println(arrayStack.outStack());
        System.out.println(arrayStack.outStack());
    }

---

动态栈代码实现

public class Node<T> {
    public T data;
    public Node<T> next;

    public Node(T data) {
        this.data = data;
    }
}

public class LinkedListStack<E> {
    private Node<E> head;
    private Node<E> tail;
    private int size = 0;


    /**
     * 入栈
     * @param e 入栈的参数
     */
    public void inStack(E e){
        final Node<E> temp = tail;
        final Node<E> newNode = new Node<>(e);
        tail = newNode;
        if (temp == null){
            head = newNode;
        }else{
            temp.next = newNode;
        }
        size++;
    }


    /**
     * 出栈
     * @return 出栈的值
     */
    public E outStack(){
        if (size<=0){
            throw new RuntimeException("The stack is null");
        }
        Node<E> temp = head;
        while (temp.next != null) {
            tail = temp;
            temp = temp.next;
        }
        tail.next = null;
        size--;
        return temp.data;
    }

    public static void main(String[] args) {
        LinkedListStack<Integer> linkedListStack = new LinkedListStack<>();
        linkedListStack.inStack(1);

        System.out.println(linkedListStack.outStack());
    }
}

时间复杂度：动态栈入栈和出栈的时间复杂度都为O(1)，因为静态栈底层由数组实现，当数组空间不够时就需要实现动态扩容，将原有的数据拷贝到新数组中，所以入栈的时间复杂度为O(n)，出栈的时间复杂度为O(1)