代码随想录DAY11

代码随想录DAY11 栈与队列

题20， 有效的括号

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

思路：

1、在学习栈和队列时看到过这道题，用栈来解题。
2、如果是左半边的括号直接压入栈中，如果是右半边的判断是否与栈顶元素相配，如果相配则弹出栈顶元素，如果不相配直接返回false。最后判断栈是否为空，空则表明全部可以配对，非空则表明false.

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.isEmpty() && stack.peek() == opposite(ch)){
                    stack.pop();
                } else{
                    return false;
                }
            }
        }
        return stack.isEmpty();
    }

    public char opposite(char c){
        if(c == ')'){
            return '(';
        }else if(c == ']'){
            return '[';
        }else if(c == '}'){
            return '{';
        }else{
            return ' ';
        }
    }
}

启发：

1、栈结构是非常适合用来做对称匹配类的题目。
2、采用Deque(double ended queue)。java中栈常用deque而很少采用Stack，因为效率不高。可以上进上出，上进下出，甚至下进上出。Deque中有很多方法，可以从两端放入和取出元素，使用的时候查阅文档。

class Solution {
    public boolean isValid(String s) {
        Deque<Character> deque = new LinkedList<>();
        char ch;
        for(int i = 0; i < s.length(); i++){
            ch = s.charAt(i);
            //压入相反的括号，方便后面对照。
            if(ch == '('){
                deque.push(')');
            }else if(ch == '['){
                deque.push(']');
            }else if(ch == '{'){
                deque.push('}');
            }else if(deque.isEmpty() || deque.peek() != ch){
                return false;
            } else{
                deque.pop();
            }
        }
        return deque.isEmpty();
    }
}

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

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
在 S 上反复执行重复项删除操作，直到无法继续删除。
在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。
示例：
输入：“abbaca”
输出：“ca”
解释：例如，在 “abbaca” 中，我们可以删除 “bb” 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 “aaca”，其中又只有 “aa” 可以执行重复项删除操作，所以最后的字符串为 “ca”。

思路：

1、遇到对称匹配问题，想到用栈结构来解题。与上一题思路类似，遍历字符串中的字符，存入栈中，存入时判断是否和栈顶元素相同，如果相同移除该元素。

启发：

可以直接对字符串采取栈类似的操作，免去了最后需要将栈转换为字符串的过程。

class Solution {
    public String removeDuplicates(String s) {
        //定义一个栈来操作
        // Deque deque = new ArrayDeque<>();
        // for(int i = 0; i < s.length(); i++){
        //     char c = s.charAt(i);
        //     if(deque.isEmpty() || deque.peek() != c){
        //         deque.push(c);
        //     } else {
        //         deque.pop();
        //     }
        // }
        // String result = "";
        // while(!deque.isEmpty()){
        //     // result += deque.pollLast();//取出最后的元素
        //     result = deque.pop() + result;
        // }
        // return result;

        //直接将字符串作为栈，省去了最后将栈转为字符串的麻烦
        StringBuffer res = new StringBuffer();
        int top = -1; //定义一个指针指向当前位置的字符串
        for(int i = 0; i < s.length(); i++){
            char c = s.charAt(i);
            if(top >= 0 && res.charAt(top) == c){
                res.deleteCharAt(top);
                top--;
            }else{
                res.append(c);
                top++;
            }
        }
        return res.toString();

    }
}

题150 逆波兰表达式求值

根据 逆波兰表示法，求表达式的值。
有效的运算符包括 + , - , * , / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。
说明：
整数除法只保留整数部分。 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。
示例 1：
输入: [“2”, “1”, “+”, “3”, " * "]
输出: 9
解释: 该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
示例 2：
输入: [“4”, “13”, “5”, “/”, “+”]
输出: 6
解释: 该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6
示例 3：
输入: [“10”, “6”, “9”, “3”, “+”, “-11”, " * ", “/”, " * ", “17”, “+”, “5”, “+”]
输出: 22

思考

1、逆波兰表达式其实是一种后缀表达式，即运算符在数字的后面。
2、遇到表达式就要取出表达式前面相应的数组进行计算，用栈结构来存放数值，根据遍历到的运算符来取出相对应数量的数值。

启发

1、自己思考的时候想的是根据遍历到的运算符来取相应的数值，看了视频以后还得应该多一个步骤，就是每一次遇到运算符就做一次计算然后将计算结果再次放入栈中，就有点像遇到运算符就将运算符和运算符前两个数值“消掉”（计算成一个值）的感觉。相邻字符消除是用栈来实现。
2、遇到数值放入栈中，遇到操作符取出两个元素做运算然后将计算结果再放入栈中。

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<Integer> deque = new ArrayDeque<>();
        for(String str: tokens){
            if("+".equals(str) || "-".equals(str) || "*".equals(str) || "/".equals(str)){
                int num1 = deque.pop();
                int num2 = deque.pop();
                System.out.println(num1);
               // System.out.println(num1,num2);
                if("+".equals(str)) { deque.push(num2 + num1);}
                if("-".equals(str)) { deque.push(num2 - num1);}
                if("*".equals(str)) { deque.push(num2 * num1);}
                if("/".equals(str)) { deque.push(num2 / num1);}//注意这里的顺序
                
            }
            else {
                deque.push(Integer.valueOf(str));//将str转换为int
            }
        }
        return deque.pop(); 
    }
}