算法题---有效的括号（乐乐独记）

1、题意描述

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

有效字符串需满足：
左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。

---

示例 1：

输入：s = “()”
输出：true

---

示例 2：

输入：s = “()[]{}”
输出：true

---

示例 3：

输入：s = “(]”
输出：false

---

示例 4：

输入：s = “([)]”
输出：false

---

示例 5：

输入：s = “{[]}”
输出：true

2、解题思路

在做这个题的时候我们需要注意以下几个点：
1、字符串的长度必须是偶数。
2、字符串的左括号与右括号在位置上也得匹配。
3、下面我给了两种解法，一种是依据于字符串，一种是依据于栈。

3、代码示例

3.1、我的解法

public class IsValid {

    public static void main(String[] args) {
        IsValid isValid = new IsValid();
        System.out.println(isValid.isValid("((})"));
    }

    public boolean isValid(String s) {
        if(null == s || "".equals(s)){
            return true;
        }
        if (s.length() % 2 == 1) {
            return false;
        }
        // 定义一个左括号临时变量字符串
        String leftBracketS = "";
        for (int index = 0; index < s.length(); index ++){
            // 逐个取出s的每个元素，如果可以与 leftBracketS 的最后一个抵消，则两个都删除，如果不可以
            char sChar = s.charAt(index);
            if(match1(sChar)){
                // 如果是左括号，就放到另一个字符串中
                leftBracketS += sChar;
            }else{
                // 如果是右括号，就去匹配，成功，则将两边都删除，不成功直接返回false
                // 1、匹配
                if("".equals(leftBracketS)){
                    // 说明还没有左括号
                    return false;
                }else{
                    // 左括号最后一位
                    String leftLast = leftBracketS.substring(leftBracketS.length() - 1);
                    boolean bool = match2(leftLast.charAt(0), sChar);
                    if(bool){
                        // 2、匹配成功，将左括号删除，进行下一位比较
                        leftBracketS = leftBracketS.substring(0, leftBracketS.length() - 1);
                        continue;
                    }else{
                        // 匹配不成功，则返回false
                        return false;
                    }
                }
            }
        }
        // 如果最后左括号和右括号都完全匹配，左括号的临时字符串变量里面肯定为空
        if(null == leftBracketS || "".equals(leftBracketS)){
            return true;
        }else{
            return false;
        }
    }

    private boolean match1(char char1){
        if('(' == char1){
            return true;
        }
        if('{' == char1){
            return true;
        }
        if('[' == char1){
            return true;
        }
        return false;
    }

    private boolean match2(char char1, char char2){
        if('(' == char1 && ')' == char2){
            return true;
        }
        if('{' == char1 && '}' == char2){
            return true;
        }
        if('[' == char1 && ']' == char2){
            return true;
        }
        return false;
    }



}

3.2、官方用栈的解法

public class IsValidUseStack {

    public static void main(String[] args) {
        IsValidUseStack isValid = new IsValidUseStack();
        System.out.println(isValid.isValid("((})"));
    }

    public boolean isValid(String s) {
        int n = s.length();
        if (n % 2 == 1) {
            return false;
        }

        Map<Character, Character> pairs = 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 (pairs.containsKey(ch)) {
                if (stack.isEmpty() || !stack.peek().equals(pairs.get(ch))) {
                    // 栈为空或者不匹配返回false
                    return false;
                }
                // 匹配不成功出栈
                stack.pop();
            } else {
                // 是左括号，入栈
                stack.push(ch);
            }
        }
        // 左括号的栈为空时，返回true
        return stack.isEmpty();
    }


    
}