【数据结构】- 栈

1. Stack栈概述

栈（Stack） 是一种 后进先出（LIFO：Last In First Out） 的数据结构。

2. Java中栈的应用

boolean isEmpty()	判断当前栈是否为空
E peek()	查看堆栈顶部的对象，但不从堆栈中移除它
E pop()	获得当前栈顶元素并删除
E push(E object)	将元素加入栈顶
int search(Object o)	返回对象再堆栈中的位置，以1为基数，由栈低向栈顶方向数

3. 底层实现

Java 集合框架中的 Stack 继承自 Vector。

栈的模拟实现

3.1 初始化栈

public class MyStack {
    
    
    public int elem[];
​
    public int usedsize;
​
    //设置一个默认的大小
    public static final int DEFAULT_SIZE = 10;
​
    public MyStack(){
    
    
        this.elem = new int[DEFAULT_SIZE];
    }
}

3.2 元素入栈

 public int push(int val){
    
    
     //将val压入栈，并返回val,判断栈是否为满，如栈满则进行扩容
     if(isFull()){
    
    
         elem = Arrays.copyOf(elem,2*elem.length);
     }
     //使用数组实现栈时，栈顶元素的下标即usedsize-1，在usedsize下标处新增元素即可
     this.elem[usedsize] = val;
     usedsize++;
     return val;
 }

判断栈满

public boolean isFull(){
    
    
        return usedsize == elem.length;
    //如果usedsize等于数组的长度则满
  }

3.3 元素出栈

 public int pop(){
    
    
    if(isEmpty()){
    
    
         throw new StackEmptyException("此时栈为空");
     }
    //先将usedsize--再返回
    return elem[--usedsize];
}

判空实现

public boolean isEmpty(){
    
    
     return usedsize == 0;
}
//自定义异常
public class StackEmptyException extends RuntimeException{
    
    
    public StackEmptyException() {
    
    
    }
    public StackEmptyException(String message) {
    
    
        super(message);
    }
}

3.4 获取栈顶元素（仅获取不改变位置）

public int peek(){
    
    
    if(isEmpty()){
    
    
        throw new StackEmptyException("此时栈为空");
    }
    return elem[usedsize-1];
}

4. 栈的应用

4.1 改变元素的序列

若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（） A: 1,4,3,2 B: 2,3,4,1 C:
3,1,4,2 D: 3,4,2,1

根据栈先进后出的性质，结合题目中进栈的过程中也可以出栈，
A选项：1进1出，2进，3进，4进，4出，3出，2出
B选项：1进，2进2出 ，3进3出， 4进4出， 1出
C选项：1进，2进，3进，3出，4进，4出，2出，1出
故C选项不可能实现。

一个栈的初始状态为空。现将元素1、2、3、4、5、A、B、C、D、E依次入栈，然后再依次出栈，则元素出栈的顺序是（ ） A:
12345ABCDE B: EDCBA54321 C: ABCDE12345 D: 54321EDCBA

先进后出，依次入栈，依次出栈，故B选项合理

4.2 逆波兰表达式求值（ 后缀表达式）

4.3 括号匹配

当遇到左括号 (、{、[，则压入栈中，当遇到右括号 )、}、]，将此右括号和栈顶括号进行匹配。如果配套，则将栈顶元素弹出，否则括号不匹配

1. 扫描到`(`，左括号压入栈中
2. 扫描到`)`，右括号与栈顶`(`匹配，执行`pop`操作
3. 扫描到`(`，左括号压入栈中
4. 扫描到`{
    
    `，左括号压入栈中
5. 扫描到`(`，左括号压入栈中
6. 扫描到`)`，右括号与栈顶`(`匹配，执行`pop`操作
7. 扫描到`}`，右括号与栈顶`{
    
    `匹配，执行`pop`操作
8. 扫描到`)`，右括号与栈顶`(`匹配，执行`pop`操作

压入栈中：指的是 Stack 中的 push 操作
弹出：指的是 Stack 中的 pop 操作
获取栈顶元素：指的是 Stack 中的 peek 操作

    // 判断代码括号是否匹配
    public static boolean match(String code) {
    
    
        Stack<Character> stacks = new Stack<>();

        for (Character c : code.toCharArray()) {
    
    
            if (c == '(' || c == '{' || c == '[') {
    
    
                stacks.push(c);
                continue;
            }

            if (c == ')') {
    
    
                if (stacks.peek() == '(') {
    
    
                    stacks.pop();
                    continue;
                }
                return Boolean.FALSE;
            }
            if (c == '}') {
    
    
                if (stacks.peek() == '{') {
    
    
                    stacks.pop();
                    continue;
                }
                return Boolean.FALSE;
            }
            if (c == ']') {
    
    
                if (stacks.peek() == '[') {
    
    
                    stacks.pop();
                    continue;
                }
                return Boolean.FALSE;
            }
        }
        return stacks.isEmpty();
    }

来源：https://blog.csdn.net/m0_56361048/article/details/127171588
括号匹配：https://blog.csdn.net/m0_52517879/article/details/123795249