代码随想录算法训练营第十一天（栈与队列）| 20. 有效的括号，1047. 删除字符串中的所有相邻重复项，150. 逆波兰表达式求值

代码随想录算法训练营第十一天（栈与队列）| 20. 有效的括号，1047. 删除字符串中的所有相邻重复项，150. 逆波兰表达式求值

20. 有效的括号

讲完了栈实现队列，队列实现栈，接下来就是栈的经典应用了。

大家先自己思考一下 有哪些不匹配的场景，在看视频 我讲的都有哪些场景，落实到代码其实就容易很多了。

题目链接/文章讲解/视频讲解：

看到题目的第一想法：

1.如果此时字符串的字符是’(‘,’[‘,’{‘时就进栈
2.在栈不为空的前提下，进行对应出栈
3.若此时字符串的字符为’)',而出栈的字符不是’(‘就返回false。其他的同理

public boolean isValid(String s) {
        Stack<Character> stack1 = new Stack<>();
        Character pop;
        for(int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if(ch == '(' || ch == '[' || ch == '{') {
                stack1.push(ch);
            }
            if(stack1.isEmpty())
                return false;
            if(ch == ')') {
                pop = stack1.pop();
                if(pop != '(')
                    return false;
            }
            else if(ch == ']') {
                pop = stack1.pop();
                if(pop != '[')
                    return false;
            }
            else if(ch == '}') {
                pop = stack1.pop();
                if(pop != '{')
                    return false;
            }
        }
        if(!stack1.isEmpty())
            return false;
        return true;
    }

看完代码随想录之后的想法：

1.如果字符串的字符为’(‘就进栈’)‘,字符为’[‘就进栈’]‘,字符为’{‘就进栈’}'.
2.如果栈为空且栈顶元素不等于预想值，则返回false
3.剩下的元素栈不为空，且等于预想值，则pop栈

public boolean isValid1(String s) {
        Stack<Character> stack1 = new Stack<>();
        for(int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if(ch == '(')
                stack1.push(')');
            else if(ch == '[')
                stack1.push(']');
            else if(ch == '{')
                stack1.push('}');
            else if(stack1.isEmpty() || stack1.pop() != ch)
                return false;
            else
                stack1.pop();
        }
        return stack1.isEmpty();
    }

自己实现过程中遇到哪些困难：

无

1047. 删除字符串中的所有相邻重复项

栈的经典应用。

要知道栈为什么适合做这种类似于爱消除的操作，因为栈帮助我们记录了 遍历数组当前元素时候，前一个元素是什么。

题目链接/文章讲解/视频讲解：

看到题目的第一想法：

1.利用栈一个个读字符串的字符，若进栈的字符与栈顶字符相等，则pop一个字符
2.遍历完字符串后，将栈中的字符添加到StringBuilder中
3.然后将构造的StringBuilder字符反向输出

package com.second.day11;

import java.util.Stack;

public class removeDuplicates_1047 {
    public String removeDuplicates(String s) {
        Stack<Character> stack = new Stack<>();
        for(int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if(!stack.isEmpty() && stack.peek() == ch)
                stack.pop();
            else
                stack.push(ch);
        }
        StringBuilder sb = new StringBuilder();
        while(!stack.isEmpty()) {
            sb.append(stack.pop());
        }
        return sb.reverse().toString();
    }
}

看完代码随想录之后的想法：

思想是一样的

自己实现过程中遇到哪些困难：

无

150. 逆波兰表达式求值

本题不难，但第一次做的话，会很难想到，所以先看视频，了解思路再去做题

题目链接/文章讲解/视频讲解：

看到题目的第一想法：

一次读取字符，如果读取的字符为操作数”+，-，*，/“，则从栈中取出两个数，然后进行对应的操作后，将计算后的数再入栈。

package com.second.day11;

import java.util.Arrays;
import java.util.Stack;

public class EvalRPN_150 {
    public int evalRPN(String[] tokens) {
        Stack<Integer> stack = new Stack<>();
        for(int i = 0; i < tokens.length; i++) {
            String ch = tokens[i];
            if(ch.equals("+") || ch.equals("-") || ch.equals("*") || ch.equals("/")) {
                int b = stack.pop();
                int a = stack.pop();
                if(ch.equals("+")) {
                    stack.push((a + b));
                }
                else if(ch.equals("*")) {
                    stack.push((a * b));
                }
                else if(ch.equals("-")) {
                    stack.push((a - b));
                }
                else {
                    stack.push((a / b));
                }
            }
            else {
                stack.push(Integer.valueOf(ch));
            }
        }
        return stack.pop();
    }

    public static void main(String[] args) {
        String[] tokens = new String[]{"2","1","+","3","*"};
        EvalRPN_150 evalRPN_150 = new EvalRPN_150();
        System.out.println(evalRPN_150.evalRPN(tokens));
    }
}

看完代码随想录之后的想法：

思路是一样的

自己实现过程中遇到哪些困难：

字符串转变为整形数字
Integer.valueOf()
Integer.parseInt()