代码随想录算法训练营第三期day11-栈与队列02

目录

1.T20：有效的括号

代码实现

2.T1047：删除字符串中的所有相邻重复项

代码实现

法1、队列作栈

法2、直接拿字符串作为栈

法3、双指针法（应该是时间上最快的）

3.T150：逆波兰表达式求值

代码实现

---

1.T20：有效的括号

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

有效字符串需满足：

• 左括号必须用相同类型的右括号闭合。

• 左括号必须以正确的顺序闭合。

• 每个右括号都有一个对应的相同类型的左括号。

提示：

• 1 <= s.length <= 104

• s 仅由括号 '()[]{}' 组成

分析一下，这里有三种不匹配的情况：

1. 第一种情况，字符串里左方向的括号多余了 ，所以不匹配。

2. 第二种情况，括号没有多余，但是 括号的类型没有匹配上。 

3. 第三种情况，字符串里右方向的括号多余了，所以不匹配。​

以上三种情况，用代码翻译过来就是：

• 第一种情况：遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号匹配，所以return false

• 第二种情况：遍历字符串匹配的过程中，发现栈里没有要匹配的字符。所以return false

• 第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号return false

那么什么时候说明左括号和右括号全都匹配了呢？就是字符串遍历完之后，栈是空的，就说明全都匹配了。

代码实现

Carl的C++代码用Java实现：

    public boolean isValid(String s) {
        if (s == null || s.length() <= 0 || s.length() % 2 != 0) return false;
        Stack stack = new Stack<>();
        for (int i = 0; i < s.length(); ++i) {
            if (s.charAt(i) == '(') {
                stack.push(')');
            } else if (s.charAt(i) == '[') {
                stack.push(']');
            } else if (s.charAt(i) == '{') {
                stack.push('}');
            } else if (stack.empty() || stack.peek() != s.charAt(i)) {
                // 第二种情况：遍历字符串匹配的过程中，发现栈里没有我们要匹配的字符。所以return false
                return false;
            } else {
                stack.pop();
            }
        }
        return stack.empty();
    }

也可以用队列写：

    public boolean isValid(String s) {
        if (s == null || s.length() <= 0 || s.length() % 2 != 0) return false;
        Deque deque = new LinkedList<>();
        char c;
        for (int i = 0; i < s.length(); ++i) {
            c = s.charAt(i);
            if (c == '(') {
                deque.push(')');
            } else if (c == '[') {
                deque.push(']');
            } else if (c == '{') {
                deque.push('}');
            } else if (deque.isEmpty() || deque.peek() != c) {
                return false;
            } else {
                deque.pop();
            }
        }
        return deque.isEmpty();
    }

2.T1047：删除字符串中的所有相邻重复项

T：给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

提示：

1. 1 <= S.length <= 20000
2. S 仅由小写英文字母组成。

S：

本题也是适合用栈来解决的题目。

那么栈里应该放的是什么元素呢？

    我们在删除相邻重复项的时候，其实就是要知道当前遍历的这个元素，我们在前一位是不是遍历过一样数值的元素，那么如何记录前面遍历过的元素呢？

    所以就是用栈来存放，那么栈的目的，就是存放遍历过的元素，当遍历当前的这个元素的时候，去栈里看一下我们是不是遍历过相同数值的相邻元素，是的话再去做对应的消除操作。 

最后，因为从栈里弹出的元素是倒序的，所以还要再对字符串进行反转一下，就得到了最终结果。

代码实现

法1、队列作栈

    注释掉的错误写法就逻辑上而言，和正解意思基本是一样的，但忽略了队列为空时的处理。

    public String removeDuplicates(String s) {
        if (s == null || s.length() == 0) return s;

        Deque deque = new ArrayDeque<>();
        for (int i = 0; i < s.length(); ++i) {
            char c = s.charAt(i);
            // if (deque.getFirst() == c) {//NoSuchElementException - if this deque is empty
            //     deque.removeFirst();
            // } else {
            //     deque.offerFirst(c);
            // }
            if (deque.isEmpty() || deque.getFirst() != c) {
                deque.offerFirst(c);
            } else {
                deque.removeFirst();
            }
        }
        String res = "";
        while (!deque.isEmpty()) {
            res = deque.removeFirst() + res;
        }
        return res;
    }

法2、直接拿字符串作为栈

    public String removeDuplicates(String s) {
        if (s == null || s.length() == 0) return s;
        StringBuffer sb = new StringBuffer();//回想一下和StringBuilder类的关系
        int top = -1;//指向栈顶的所在
        char c;
        for (int i = 0; i < s.length(); ++i) {
            c = s.charAt(i);
            if (top >= 0 && c == sb.charAt(top)) {
                sb.deleteCharAt(top--);
            } else {
                sb.append(c);
                ++top;
            }
        }
        return sb.toString();
    }

法3、双指针法（应该是时间上最快的）

    public String removeDuplicates(String s) {
        if (s == null || s.length() == 0) return s;
        char[] ch = s.toCharArray();
        int slow = 0;
        for (int fast = 0; fast < s.length(); ++fast) {
            // if (ch[fast] != ch[slow]) {//索引越界风险
            //     ch[++slow] = ch[fast];
            // } else {
            //     --slow;
            // }
            ch[slow] = ch[fast];//跟去除重复元素那题一样，赋值的过程中免不了做无用功
            if (slow > 0 && ch[slow] == ch[slow - 1]) {
                --slow;
            } else {
                ++slow;
            }
        }
        return new String(ch, 0, slow);
    }

需要注意到的是，3种方法都对索引越界做了防范

3.T150：逆波兰表达式求值

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

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

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

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

提示：

• 1 <= tokens.length <= 104

• tokens[i] 是一个算符（"+"、"-"、"*" 或 "/"），或是在范围 [-200, 200] 内的一个整数

逆波兰表达式：

逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

• 平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。

• 该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

• 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。

• 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

S：这题只要学过中缀和后缀（逆波兰）表达式之间转换就不难写出，就不多废话了

代码实现

    public int evalRPN(String[] tokens) {
        if (tokens == null || tokens.length == 0) return -1;//不知道返回什么
        Deque stack = new ArrayDeque<>();
        // Integer top;
        for (String s : tokens) {
            if (s.equals("+")) {
                // top = stack.pop();
                stack.push(stack.pop() + stack.pop());
            } else if (s.equals("-")) {
                // stack.push(stack.pop() - stack.pop());
                stack.push(- stack.pop() + stack.pop());
            } else if (s.equals("*")) {
                stack.push(stack.pop() * stack.pop());
            } else if (s.equals("/")) {
                // stack.push(1 / (stack.pop() / stack.pop()));//ArithmeticException: / by zero
                Integer top = stack.pop();
                stack.push(stack.pop() / top);
            } else {
                stack.push(Integer.valueOf(s));
            }
        }
        return stack.pop();
    }

在else if (s.equals("/")) {}中，原先想用取倒数的方式，结果如下（懂得都动，不解释了）：

java.lang.ArithmeticException: / by zero

    at line 16, Solution.evalRPN

    at line 54, __DriverSolution__.__helper__

    at line 84, __Driver__.main