【刷题日记】有效的括号，逆波兰表达式求值,栈的压入和弹出序列

本章博客题均出自力扣，牛客，展示语言为Java。

目录

一、有效的括号

二、逆波兰表达式求值

三、栈的压入、弹出序列

一、有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。
3. 每个右括号都有一个对应的相同类型的左括号。

 分析：

本题主要利用栈的思想来解题，主要是分为三个情况：括号之间不匹配，左括号多，右括号多。

源代码：

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 top = stack.peek();
              if(top == '(' && ch == ')' || top == '[' && ch == ']' || top == '{' && ch == '}') {
                    stack.pop();
                }else{
                    return false;
                }        
            }
        }
        if(stack.empty()) {
            return true;
        }else{
            return false;
        }
    }
}

 本题链接：力扣

二、逆波兰表达式求值

根据 逆波兰表示法，求表达式的值。

有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

注意 两个整数之间的除法只保留整数部分。

可以保证给定的逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。

 该题思想来自于博主的这篇博客：

【JavaSE与数据结构】栈与Stack

值得注意的是,这里的isOperation函数比较的是：引用类型，如果用'='比较则会出错。

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(!isOperation(ch)) {
                stack.push(Integer.parseInt(ch));
            }else {
                //遇到符号 弹出两个元素
                int num1 = stack.pop();
                int num2 = stack.pop();
                switch(ch) {
                    case "+":
                    stack.push(num2 + num1);
                    break;
                    case "-":
                    stack.push(num2 - num1);
                    break;
                    case "*":
                    stack.push(num2 * num1);
                    break;
                    case "/":
                    stack.push(num2 / num1);
                    break;
                } 
            }
        } 
        return stack.pop();
    }
    public boolean isOperation(String ch) {
        if(ch.equals("+") || ch.equals("-") || ch.equals("*") || ch.equals("/")){
            return true;
        }else {
            return false;
        }
    }
}

 本题链接：力扣

三、栈的压入、弹出序列

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。

1. 0<=pushV.length == popV.length <=1000

2. -1000<=pushV[i]<=1000

3. pushV 的所有数字均不相

本题思路：

两个数组，分别遍历，第一个push数组，在每一次将自身元素压入栈后，都与pop数组的元素对比一下，如果相等，则从栈中弹出该元素，并让在pop元素的指向，指向下一个元素。

当然可以会遇到一下子就将栈中元素都弹完的情况（避免后续空指针访问异常），所以需在while循环中判断：是否栈为空，指向pop数组元素的‘指针’是否越界。 

源代码：

import java.util.ArrayList;
import java.util.*;


public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        Stack<Integer> stack = new Stack<>();
        int j = 0;
        for(int i = 0; i < pushA.length; i++ ) {
            stack.push(pushA[i]);
            while( !stack.empty() && j < popA.length && stack.peek() == popA[j]) {
                stack.pop();
                j++;
            }
        }
        return stack.empty();

    }
}

本题链接:栈的压入、弹出序列_牛客题霸_牛客网