【数据结构-Java语言描述】栈

微信公众号：程序员Alex
关注可了解更多的编程知识。问题或建议，请公众号留言;
如果你觉得文章对你有帮助，欢迎收藏

栈

​ 堆栈（英语：stack）又称为栈或堆叠**，是计算机科学中的一种抽象数据类型，只允许在有序的线性数据集合的一端（称为堆栈顶端，英语：top）进行加入数据（英语：push）和移除数据（英语：pop）的运算。因而按照后进先出（LIFO, Last In First Out）的原理运作。

栈的实现

1. 数组实现

   

2. 链表实现

   

栈的操作

堆栈使用两种基本操作：推入（压栈，push）和弹出（弹栈，pop）：

• 推入：将数据放入堆栈顶端，堆栈顶端移到新放入的数据。
• 弹出：将堆栈顶端数据移除，堆栈顶端移到移除后的下一笔数据。

栈的特点

堆栈的基本特点：

1. 先入后出，后入先出。
2. 除头尾节点之外，每个元素有一个前驱，一个后继。

代码实现

栈的数组实现

public class MyStack<T> {
    /**
     * 栈
     */
    private Object[] stack;
    /**
     * 栈的大小
     */
    private int size;
    MyStack() {
        stack = new Object[10];
    }
    private void push(T t) {
        reSize();
        stack[size] = t;
        size++;
    }
    private T pop() {
        T t = peek();
        if (size > 0) {
            size--;
        }
        return t;
    }
    private T peek() {
        T t = null;
        if (size > 0) {
            t = (T) stack[size - 1];
        }
        return t;
    }
    private void reSize() {
        if (stack.length < size + 1) {
            Arrays.copyOf(stack, stack.length * 2);
        }
    }

    /**
     * 判断栈是否为空
     *
     * @return
     */
    private boolean isEmpty() {
        return size == 0;
    }
    public static void main(String[] args) {
        MyStack<Integer> stack = new MyStack();
        stack.push(1);
        int t = stack.pop();
        System.out.println(t);
    }
}

栈的链表实现

public class MyStack2<T> {

    @Data
    class Node<T> {
        private T value;
        private Node next;
    }

    private Node stack;

    MyStack2() {
        stack = null;
    }

    /**
     * 获取栈顶数据
     *
     * @return
     */
    private T peek() {
        T t = null;
        if (Objects.nonNull(stack)) {
            t = (T) stack.value;
        }
        return t;
    }

    private T pop() {
        T t = peek();
        Node newHead = stack.next;
        stack = newHead;
        return t;
    }

    private void push(T t) {
        Node node = new Node();
        node.setValue(t);
        if (isEmpty()) {
            node.setNext(null);
            stack = node;
            return;
        }
        Node temp = stack;
        node.setNext(temp);
        stack = node;
    }

    private Boolean isEmpty() {
        return Objects.isNull(stack);
    }

    public static void main(String[] args) {
        MyStack2<Integer> stack = new MyStack2();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
    }
}

时间复杂度

由于所有操作都是在栈顶，所以pop和posh的时间复杂度都是O(1)