谷歌（Google）历年编程真题——有效的括号

谷歌历年面试真题——数组和字符串系列真题练习。

有效的括号

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

有效字符串需满足：

• 左括号必须用相同类型的右括号闭合。
• 左括号必须以正确的顺序闭合。
• 每个右括号都有一个对应的相同类型的左括号。

示例 1：

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

示例 2：

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

示例 3：

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

提示：

• 1 <= s.length <= 104
• s 仅由括号 ‘()[]{}’ 组成

思路一：栈

要判断给定的字符串是否有效，可以使用栈来实现。具体步骤如下：

1. 遍历字符串，对于每个字符：
   • 如果是左括号（即 '(', '[', '{'），将其压入栈中。
   • 如果是右括号（即 ')', ']', '}'），则需要检查栈顶元素是否与当前右括号匹配，如果不匹配或者栈为空，则返回 False。
2. 如果遍历完成后栈为空，则说明所有左括号都有相应的右括号与之匹配，返回 True，否则返回 False。

下面是相应的 Python 代码实现：

def isValid(s: str) -> bool:
    stack = []
    mapping = {')': '(', ']': '[', '}': '{'}
    for char in s:
        if char in mapping.values():
            stack.append(char)
        elif char in mapping.keys():
            if not stack or stack.pop() != mapping[char]:
                return False
        else:
            return False
    return not stack

# 示例测试
print(isValid("()"))  # 输出: True
print(isValid("()[]{}"))  # 输出: True
print(isValid("(]"))  # 输出: False

这种方法的时间复杂度为 O(n)，其中 n 是字符串的长度。因为只遍历一次字符串，并且栈操作的时间复杂度也是 O(1)。

思路二：递归

除了使用栈之外，还可以使用递归的方法来判断字符串是否有效。具体思路如下：

1. 定义一个递归函数 isValidSubstring(s: str) -> bool，该函数用于判断给定的字符串 s 是否为有效字符串。
2. 在递归函数中，如果字符串 s 为空，则返回 True。
3. 否则，首先判断字符串的开头字符和结尾字符是否匹配，如果不匹配，则返回 False。
4. 如果匹配，则将字符串 s 去掉开头和结尾字符，继续递归判断剩余部分。
5. 递归的终止条件是字符串长度为 0 或 1。

下面是相应的 Python 代码实现：

def isValid(s: str) -> bool:
    def isValidSubstring(sub: str) -> bool:
        if not sub:
            return True
        if sub[0] == '(' and sub[-1] == ')':
            return isValidSubstring(sub[1:-1])
        elif sub[0] == '[' and sub[-1] == ']':
            return isValidSubstring(sub[1:-1])
        elif sub[0] == '{' and sub[-1] == '}':
            return isValidSubstring(sub[1:-1])
        else:
            return False

    return isValidSubstring(s)

# 示例测试
print(isValid("()"))  # 输出: True
print(isValid("()[]{}"))  # 输出: True
print(isValid("(]"))  # 输出: False

这种方法也能有效判断字符串是否有效，其时间复杂度取决于递归的深度，最坏情况下为 O(n)，其中 n 是字符串的长度。

思路三：迭代

除了使用栈和递归之外，还可以使用迭代的方法来判断字符串是否有效。具体思路如下：

1. 定义两个计数器 open_count 和 close_count，分别用于记录开放括号和闭合括号的数量。
2. 遍历字符串，对于每个字符：
   • 如果是左括号（即 '(', '[', '{'），则增加 open_count。
   • 如果是右括号（即 ')', ']', '}'），则增加 close_count。
   • 如果在任何时候 close_count 大于 open_count，则说明右括号出现在了左括号之前，返回 False。
3. 最后，如果 open_count 等于 close_count，则返回 True，否则返回 False。

下面是相应的 Python 代码实现：

def isValid(s: str) -> bool:
    open_count = close_count = 0
    for char in s:
        if char == '(' or char == '[' or char == '{':
            open_count += 1
        elif char == ')' or char == ']' or char == '}':
            close_count += 1
            if close_count > open_count:
                return False
    return open_count == close_count

# 示例测试
print(isValid("()"))  # 输出: True
print(isValid("()[]{}"))  # 输出: True
print(isValid("(]"))  # 输出: False

这种方法的时间复杂度为 O(n)，其中 n 是字符串的长度。因为只需要遍历一次字符串即可完成判断。