栈Java实现

栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

public interface MyStack<T> {
    /**
     * 判断栈是否为空
     */
    boolean isEmpty();
    /**
     * 清空栈
     */
    void clear();
    /**
     * 栈长
     */
    int length();
    /**
     * 入栈
     */
    boolean push(T data);
    /**
     * 出栈
     */
    T pop();
}

顺序栈，底层数组

public class Stack<T> implements MyStack<T> {
    private Object[] object = new Object[10];
    private int size = 0;
         @Override
    public boolean isEmpty() {
        return size == 0;
    }

    <span style="white-space:pre">  </span>@Override
    public void clear() {
        for (int i = 0; i < size; i++) {
            object[i] = null;
        }
        size = 0;
    }

    @Override
    public int length() {
        return size;
    }

    @Override
    public boolean push(T data) {
        if (size >= object.length) {
            expand();
        }
        object[size++] = data;
        return true;
    }

    private void  expand() {
        Object[] temp = new Object[object.length * 3 / 2 + 1];
        for (int i = 0; i < size; i++) {
            temp[i] = object[i];
            object[i] = null;
        }
        object = temp;
    }

    @Override
    public T pop() {
        if (size == 0) {
            return null;
        }
        return (T) object[--size];
    }


    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("ArrayStack: [");
        for (int i = 0; i < size; i++) {
            sb.append(object[i].toString());
            if (i != size - 1) {
                sb.append(", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

链栈，底层链表

public class LinkedStack<T> implements MyStack<T> {

    /**
     * 栈顶指针
     */
    private Node top;
    /**
     * 栈长
     */
    private int size;

    public LinkedStack() {
        top = null;
        size = 0;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public void clear() {
        top = null;
        size = 0;
    }

    @Override
    public int length() {
        return size;
    }

    @Override
    public boolean push(T data) {
        Node node = new Node();
        node.data = data;
        node.pre = top;
        // 改变栈顶指针
        top = node;
        size++;
        return true;
    }

    @Override
    public T pop() {
        if (top != null) {
            Node node = top;
            // 改变栈顶指针
            top = top.pre;
            size--;
            return node.data;
        }
        return null;
    }

    private final class Node {
        private Node pre;
        private T data;
    }
}