栈和队列的具体使用（上）

---

前言

本文主要介绍使用栈所完成的一些题目。

一、最小栈

力扣链接： link

1.1实现思路

1. 利用两个栈，一个为正常栈(保存所有的进出栈数据)，一个为最小栈(只有当数据为最小时，才会入栈)
2. 核心在于：入栈时，若数据最小，需要两个栈都要入栈，出栈时，如果出的数据为最小，需要更新最小栈

2.2具体实现

class MinStack {

    Stack<Integer> stack;
    Stack<Integer> minstack;

    public MinStack() {
        stack = new Stack<>();
        minstack = new Stack<>();
    }
    // 入栈时：
    // 数据栈：每次都要压入一个元素
    // 最小值栈：当最小值栈为空 或者 当前插入元素小于最小值栈栈顶元素时入栈
    public void push(int val) {
        stack.push(val);
        if (minstack.empty()) {
            minstack.push(val);
        } else {
            int num = minstack.peek();
            if (num >= stack.peek()) {
                minstack.push(val);
            }
        }

    }
    // 出栈时：
    // 最小值栈：栈顶与数据栈栈顶元素相等时才可以出
    // 数值栈每次都要出一个元素
    public void pop() {
        int val = stack.pop();
        if (minstack.peek() == val) {
            minstack.pop();
        }
    }

    public int top() {
        return stack.peek();
    }

    public int getMin() {
        return minstack.peek();
    }
}

二、括号匹配问题

力扣链接：link

2.1实现思路

循环遍历String中的字符，逐个取到每个括号，如果该括号是：
    1. 左括号，直接入栈
    2. 右括号，与栈顶的左括号进行匹配，如果不匹配直接返回false
       否则继续循环
 循环结束后，如果栈空则匹配，否则左括号比右括号多肯定不匹配

2.2具体实现

class Solution {
     public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char ch= s.charAt(i);
            if (ch=='(' || ch=='['  || ch=='{' ) {
                stack.push(ch);
            } else {
                if (stack.empty()) {
                    return false;
                }
               char ch2= stack.peek();
                if(ch2=='('&&ch==')'||ch2=='['&&ch==']'||ch2=='{'&&ch=='}'){
                    stack.pop();
                }else{
                    return false;
                }
            }
        }
        return stack.empty();
    }
}

三、逆波兰表达式求值

力扣链接：link

3.1实现思路

  对tokens数组进行遍历，依次获取到每个元素，如果：
    1. 该元素是数字(注意：不是运算符肯定是数字)，将该数字入栈
    2. 该元素是运算符，从栈顶获取该运算符对应的右、左操作数进行相应的操作，最后将结果入栈
  循环结束后，栈顶的元素就是最终表达式的结果

3.2具体实现

class Solution {
 public int evalRPN(String[] tokens) {
    Stack<Integer> stack=new Stack<>();
    for(int i=0;i<tokens.length;i++){
        String ch=tokens[i];
        if(!isOperations(ch)){
            int val=Integer.valueOf(ch);
            stack.push(val);
        }else{
            int num1=stack.pop();
            int num2=stack.pop();
            switch (ch) {
            case "+":
                stack.push(num1+num2);
            break;
            case "-":
                stack.push(num2-num1);
                break;
            case "*":
                stack.push(num1*num2);
                break;
            case "/":
                stack.push(num2/num1);
                break;}
        }
    }
    return  stack.pop();
}
//判断该操作数是不是运算符
    private boolean isOperations(String ch){
        if(ch.equals("+")||ch.equals("-")||ch.equals("*")||ch.equals("/")){
            return true;
        }
        return false;
    }
}

四、栈的弹出压入序列

牛客链接：link

4.1实现思路

  入栈：当栈为空，或者栈顶元素和待出栈元素不相等时
       注意：入栈时要保证有元素，如果没有元素则一定不相等
  出栈：当栈顶元素待出栈元素相同时出栈
  循环进行上述过程即可，直到所有的元素全部出栈

4.2具体实现

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param pushV int整型一维数组
     * @param popV int整型一维数组
     * @return bool布尔型
     */
    public boolean IsPopOrder (int[] pushV, int[] popV) {
        Stack<Integer> stack = new Stack<>();
        int j = 0;
        for (int i = 0; i < pushV.length; i++) {
            stack.push(pushV[i]);
            while (!stack.empty() && j < popV.length && stack.peek() == popV[j]) {
                stack.pop();
                j++;
            }
        }
        return stack.empty();
    }
}