栈（Stack）

一，概念

• 一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则
• 栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶
• 栈的删除操作叫做出栈。出数据在栈顶

二，栈的操作

 代码示例：
 

public class MyStack {

    public static void main(String[] args) {
        Stack s = new Stack();

        //入栈
        s.push(1);
        s.push(2);
        s.push(3);
        s.push(4);
        s.push(5);
        s.push(6);

        //获取栈顶元素                   (栈中元素遵循后进先出，因此元素为：1，2，3，4，5，6）
        System.out.println(s.peek());

        //获取有效元素的个数                 （一共有六个元素，因此为；6)
        System.out.println(s.size());

        //出栈（获取并取出）                  (出栈并检测栈顶元素和栈中元素的个数）
        System.out.println(s.pop());         //      6
        System.out.println(s.pop());         //      5
        System.out.println(s.pop());         //      4
        System.out.println(s.pop());         //      3
        System.out.println(s.peek());        //      2
        System.out.println(s.size());        //      2
        //判断栈里面是否为空
        if(!s.empty()){
            System.out.println("栈不为空！");
        }else {
            System.out.println("栈为空！");
        }
        System.out.println(s.pop());
        System.out.println(s.pop());

        if(!s.empty()){
            System.out.println("栈不为空！");
        }else {
            System.out.println("栈为空！");
        }
    }
}

运行结果：

 

三，栈的应用实例

逆序打印链表

思路：可以借用栈的特性“后进先出”，后入栈的先出去

public void print(ListNode head){
        if(head == null){
            System.out.println("链表为空！");
        }
        ListNode cur = head;
        Stack s = new Stack();
        while(cur != null){
            s.push(cur.val);
            cur = cur.next;
        }
        while(!s.empty()){
            System.out.print(s.pop() + " ");
        }
        System.out.println();
    }

 在剑指刷题中，有两种做法，普通数组逆序，和利用栈的逆序

四，栈的模拟实现

public static class Stack<E> {
        E[] array;
        int size;   // 用来表示栈中总共有多少个元素 || size-1表示栈顶元素的位置
        public Stack(){
            array = (E[])new Object[3];
            size = 0;
        }

        public void push(E e){
            // 1. 先确保栈中空间足够
            ensureCapacity();

            // 2. 插入元素
            array[size] = e;
            size++;
        }

        public E pop(){
            E ret = peek();
            size--;
            return ret;
        }

        public E peek(){
            if(empty()){
                throw new RuntimeException("pop: 栈是空的");
            }

            return array[size-1];
        }

        public boolean empty(){
            return 0 == size;
        }

        public int size(){
            return size;
        }

        private void ensureCapacity(){
            if(size == array.length){
                int newCapacity = size*2;
                array = Arrays.copyOf(array, newCapacity);
            }
        }

        public static void main(String[] args) {
            Stack<String> s = new Stack<>();
            s.push("11");
            s.push("22");
            s.push("33");
            s.push("44");
            s.push("55");
            s.push("66");
            s.push("77");
            System.out.println(s.size());
            System.out.println(s.peek());

            s.pop();
            s.pop();
            System.out.println(s.size());
            System.out.println(s.peek());
        }
    }

 

五，栈，虚拟机栈，栈帧的区别

栈：一般认为时一种数据结构，它继承了vector，在java集合中实现了Stack，也是线程安全的

虚拟机栈： 具有特殊作用的一块内存，jvm为了更好的管理数据，将内存按照不同的需求划分出来的一种结构（堆区，栈区）

栈区是线程私有的，存放的是一些有关于函数调用的信息，主要是栈帧，如果栈区内存不够时，会抛出StackoverflowException的异常，当中的元素（栈帧）是按照数据结构中栈的特性来实现的

 栈帧：一种与函数调用有关的结构，如，局部变量，操作数栈。每个方法在调用时，jvm都会创建一个栈帧，将栈帧压入到虚拟机栈中，当方法调用结束时，对应的栈帧就会从虚拟机栈中出栈