678. 有效的括号字符串（栈：两个栈分别存储）

有效的括号字符串

给定一个只包含三种字符的字符串：（ ，） 和 *，写一个函数来检验这个字符串是否为有效字符串。有效字符串具有如下规则：

任何左括号 ( 必须有相应的右括号 )。任何右括号 ) 必须有相应的左括号 ( 。左括号 ( 必须在对应的右括号之前 )。* 可以被视为单个右括号 ) ，或单个左括号 ( ，或一个空字符串。一个空字符串也被视为有效字符串。

示例 1:
输入: “()”
输出: True

示例 2:
输入: “(*)”
输出: True

示例 3:
输入: “(*))”
输出: True

---

解题思路

栈(先进后出)
定义两个栈，leftStack 存 ’ ( ’ 所在位置的下标，starStack 存 ‘*’ 所在位置的下标。

1.当遇到 ’ ( ’ 时，’ ( ’ 所在位置的下标入栈；当遇到 ’ * ’ 时，’ * ’ 所在位置的下标入栈。

2.当遇到 ’ ) ’ 时，要令 leftStack 中的栈顶元素出栈，若此时 leftStack 为空，则继续看 starStack 是否为空，若不为空则 starStack 栈顶元素出栈，若为空返回则 false (遇到了 ’ ) '，但在这之前一个 ’ ( ’ 和 ’ * ’ 都没遇到，则一定不会匹配)。

3.当字符串全部遍历完时，若 starStack 的长度比 leftStack 的长度要小，则返回 false (有剩余的 ’ ( '，但 ’ * ’ 的数量不够了，则一定不会匹配)；否则，比较两个栈的栈顶元素值的大小，要保证 ’ ( ’ 在 ’ * ’ 的左边(starStack.peek() > leftStack.peek())才能匹配成功，当遇到满足条件的栈顶元素时，栈顶元素出栈，继续比较下一个。只要有一次该条件不满足，则直接返回 false；否则，返回 true。

---

代码

class Solution {

    public boolean checkValidString(String s) {

        int n = s.length();
        Stack<Integer> leftStack = new Stack<>();
        Stack<Integer> starStack = new Stack<>();

        for (int i=0;i<n;i++) {

            if (s.charAt(i) == '(') {

                leftStack.push(i);//存的是下标
            } else if (s.charAt(i) == '*') {

                starStack.push(i);
            } else {

                if (!leftStack.isEmpty()) {

                    leftStack.pop();
                } else {

                    if (!starStack.isEmpty()) {
                    
                        starStack.pop();
                    } else {

                        return false;
                    }
                }
            }
        }
        if (starStack.size() < leftStack.size()) return false;
        else {

            while (!starStack.isEmpty() && !leftStack.isEmpty()) {

                if (starStack.peek() < leftStack.peek()) {

                    return false;
                }
                starStack.pop();
                leftStack.pop();
            }
            return true;
        }
    }
}

时间复杂度：因为只有一次 for 循环的遍历，所以复杂度为 O(n)
空间复杂度：因为开辟了两个栈，长度为n，最坏情况下是一个栈全用，所以复杂度O(n)