栈的使用——《有效的括号》

题目链接：力扣https://leetcode-cn.com/problems/valid-parentheses/solution/you-xiao-de-gua-hao-by-leetcode-solution/

 

 

 

一， 规律与思想：

1，从左往右，遇到的第一个右括号，一定是和它紧挨左边的那个左括号是一对的，否则就是false；

2，先进后出的规律：先出现的左括号后匹配，后出现的左括号先匹配；这就是先进后出的模式，那么可以使用栈这种数据结构来辅助完成操作；

3，我们可以把左括号加入栈，匹配成功的过程就是栈顶元素出栈的过程；

4，将右括号为键、左括号为值，存入一个map中；

自左向右的扫描字符串，

如果是左括号，则进栈、等待匹配；

如果是右括号，则判断该右括号对应的map值是否和栈顶元素是相等的；

如果是相等的，则不需要再考虑这一对括号，将该栈顶元素（左括号）进行出栈。

如果是不相等的，则返回false；

最后，完全匹配的条件是栈为空；

二，代码示例：

public class ValidParentheses {
    private static Map<Character, Character> inMap = new HashMap<>();

    static {
        inMap.put(')', '(');
        inMap.put('}', '{');
        inMap.put(']', '[');
    }

    public static void main(String[] args) {
        // {[]}  true   s = "()"   s = "()[]{}"     s = "{[]}"    s = "{[()]}"  {[]}  "{[]}"  "[({(())}[()])]"
        // false  s = "(]"   s = "([)]"  "[({])}"   "(){}}{"
        boolean valid = isValid2("(){}}{");
        System.out.println("valid = " + valid);

    }

    /**
     * 从左往右，遇到的第一个右括号一定是和它紧挨左边的那个左括号是一对的，否则就是false；
     * @param s：举例：()、()[]{}、{[()]}、[({(())}[()])]、(]、([)]、[({])}
     * @return
     */
    public static boolean isValid2(String s) {
        //新建一个栈：
        Deque<Character> charStack = new LinkedList<>();
        for (int i = 0; i < s.length(); i++) {
            char item = s.charAt(i);
            if (inMap.containsKey(item)) {  //如果当前元素是一个右括号：
                //则执行和栈顶元素左括号的匹配操作：
                if (charStack.isEmpty()) {  //如果还有右括号，但是栈却空了、没有了与之匹配的左括号，则返回false；
                    return false;
                }
                //如果当前元素右括号对应的左括号和栈顶元素左括号相等，则匹配成功，进行该栈顶元素出栈操作；
                if (inMap.get(item).equals(charStack.peekFirst())) {
                    charStack.pop();
                }else{ //否则返回false：
                    return false;
                }
            }else {  //如果当前元素是一个左括号：
                //则执行入栈操作：
                charStack.push(item);
            }
        }
        //最后，判断该栈是否是空的，如果不是空的，则说明有没匹配成功的左括号，那么返回false；
        if (charStack.isEmpty()) {
            return true;
        }else {
            return false;
        }
    }


    /**
     * 立扣官方答案：
     * @param s
     * @return
     */
    public static boolean isValid(String s) {
        int n = s.length();
        if (n % 2 == 1) {
            return false;
        }
        Map<Character, Character> inMap = new HashMap<Character, Character>() {{
            put(')', '(');
            put(']', '[');
            put('}', '{');
        }};
        Deque<Character> stack = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            char ch = s.charAt(i);
            if (inMap.containsKey(ch)) {
                if (stack.isEmpty() || stack.peek() != inMap.get(ch)) {
                    return false;
                }
                stack.pop();
            } else { //如果是左括号，则入栈，等待匹配；
                stack.push(ch);
            }
        }
        return stack.isEmpty();
    }


}

三，总结：

1，先进后出规律，使用栈这种数据结构作为辅助，来完成操作；

 

2，新建一个栈：

Deque<Character> charStack = new LinkedList<>();

 

3，Deque和Queue的区别；

• 前者是后者的子接口；
• 前者是双端队列，一般用于栈和队列的操作，子类LinkedList一般用于栈，子类ArrayDeque一般用于队列；
• 后者是单端队列，一般用于堆的操作；

 

4，peek()方法与peekFirst()方法：

peekFirst()方法：检索但不删除此双端队列的第一个元素，如果此双端队列为空，则返回null 。

peek()方法：检索但不删除此双端队列表示的队列的头部（换句话说，此双端队列的第一个元素），如果此双端队列为空，则返回null 。
注意：此方法等效于peekFirst() 。