1
2

输入: "()"
输出: true

1
2

输入: "()[]{}"
输出: true

1
2

输入: "(]"
输出: false

1
2

输入: "([)]"
输出: false

1
2

输入: "{[]}"
输出: true

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

struct Solution;

// @lc code=start
impl Solution {
    /// ## 解题思路
    /// - 栈+hashmap
    pub fn is_valid(s: String) -> bool {
        use std::collections::HashMap;
        let mut tmp = vec![];
        let pairs = HashMap::from([
            (')', '('),
            ('}', '{'),
            (']', '['),
        ]);
        for c in s.chars() {
            match c {
                '('|'['|'{' => {
                    tmp.push(c);
                },
                ')'|']'|'}' => {
                    if tmp.last() != pairs.get(&c) {
                        return false;
                    } else {
                        tmp.pop();
                    }
                },
                _ => {}
            }
        }
        return tmp.len() == 0;
    }
}
// @lc code=end

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

class Solution {
public:
    bool isValid(string s) {
        stack<char> parens;
        map<char, char> pairs = {
            {')', '('},
            {'}', '{'},
            {']', '['},
        };

        for(char& c: s) {
            switch(c) {
                case '(':
                case '{':
                case '[': parens.push(c); break;
                case '}':
                case ']':
                case ')': {
                    if (parens.empty() || parens.top() != pairs[c] ) {
                        return false;
                    } else {
                        parens.pop();
                    }
                    break;
                }
                default:
                    break;

            }
        }

        return parens.empty();
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Solution:
    def isValid(self, s: str) -> bool:
        pairs = {
            '{': '}',
            '[': ']',
            '(': ')'
        }
        stack = []
        if len(s) == 0:
            return True
        if len(s) % 2 == 1:
            return False

        for c in s:
            if c in pairs:
                stack.append(pairs.get(c))
            elif len(stack) == 0:
                return False
            else:
                if c != stack.pop():
                    return False

        return len(stack) == 0