数据结构：栈

---

一、介绍

• 栈是一个先入后出(FILO-First In Last Out)的有序列表。
• 栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表
• 允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。
• 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除

图解栈的执行流程如下：

---

二、栈的应用场景

• 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
• 处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。
• 表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。
• 二叉树的遍历。
• 图形的深度优先(depth 一 first)搜索法。

---

三、栈实现

3.1、数组模拟栈

• 定义 top 表示栈顶，初始值为 -1
• 入栈：指针上移：top++ 赋值：stack[top] = data;
• 出栈：指针下移：top-- 返回值 return stack[top];
• 栈空：top == -1
• 栈满：top == maxSize-1

class ArrayStack{
    private int maxSize;  //栈的大小
    private int[] stack;  //模拟栈的数组
    private int top = -1; //初始化为栈顶

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }
    
    // 栈满
    public boolean ifFull(){
        return top == maxSize -1;
    }
    
    // 栈空
    public boolean isEmpty(){
        return top == -1;
    }

	// 入栈
    public void push(int value){
        if (ifFull()){
            System.out.println("栈满");
            return;
        }
        top ++;
        stack[top] = value;
    }

	// 出栈
    public int pop(){
        if (isEmpty()){
            throw new RuntimeException("栈空，没有数据");
        }
        int res = stack[top];
        top --;
        return res;
    }
    
    //遍历
    public void list(){
        if (isEmpty()){
            System.out.println("栈空，没有数据");
        }
        for (int i = top; i >= 0; i--){
            System.out.print(stack[i] + " ");
        }
        System.out.println();
    }

}

---

3.2、链表模拟栈

• 定义头节点空数据但不能为null，头节点至关重要
• 压栈：头插法压栈，从头节点开始寻找下一个节点是否为空，为空则插入
• 弹栈：头节点引用为当前节点并弹出数据 head = head.next

class LinkedStack {
    //定义一个头节点
    private Node head = new Node();
    //定义链表大小
    private final int maxSize;
    private int top = -1;

    public LinkedStack(int maxSize) {
        this.maxSize = maxSize;
    }

    public boolean isFull() {
        return top == maxSize - 1;
    }

    public boolean isEmpty() {
        return top == -1;
    }

    public void push(int value) {
        Node temp = head;
        if (isFull()) {
            return;
        }
        // 头插法：遍历寻找空位
        while (temp.getNext() != null) {
            temp = temp.getNext();
        }
        // 找到空位进行插入
        Node res = new Node(value);
        temp.setNext(res);
        top++;
    }

    public int pop() {
        if (isEmpty()) {
            return -1;
        }        
        int res = head.getNext().getData();
        // 移动head指针为当前节点，为下一次弹出做准备
        head = head.getNext();
		top--;
        return res;
    }

    public void show() {
        Node temp = head.getNext();
        if (isEmpty()) {
            return;
        }
        while (temp != null) {
            System.out.print(temp.getData() + " ");
            temp = temp.getNext();
        }
        System.out.println();
    }

}

class Node {
    private int data;
    private Node next;

    public Node() {
    }

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

    public Node(Node next) {
        this.next = next;
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}