有效的括号
- 标签：栈|递归
题目
> 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
>
> 有效字符串需满足：
>
> 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 每个右括号都有一个对应的相同类型的左括号。
>
> 示例 1：
>
> 输入：s = "()" 输出：true
示例 2：
>
> 输入：s = "()[]{}" 输出：true
> 示例 3：
>
> 输入：s = "(]" 输出：false
>
> 提示：
>
> 1 <= s.length <= 104 s 仅由括号 '()[]{}' 组成
>
思路及实现
方式一：栈（推荐）
思路
判断括号的有效性可以使用「栈」这一数据结构来解决。
代码实现
Java版本
import java.util.Stack;
// leetcode submit region begin(Prohibit modification and deletion)
class Solution {
public boolean isValid(String s) {
Stack<Character> stack = new Stack<>(); // 创建一个栈用于存储左括号字符
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c == '(' || c == '[' || c == '{') {
stack.push(c); // 如果是左括号字符，将其压入栈中
} else {
if (stack.isEmpty()) {
return false; // 如果栈为空，说明缺少左括号，返回false
}
char top = stack.pop(); // 弹出栈顶元素
if (c == ')' && top != '(') {
return false; // 如果当前字符是右括号且与栈顶元素不匹配，返回false
}
if (c == ']' && top != '[') {
return false;
}
if (c == '}' && top != '{') {
return false;
}
}
}
return stack.isEmpty(); // 最后判断栈是否为空，如果为空说明每个左括号都有匹配的右括号，则返回true，否则返回false
}
}
// leetcode submit region end(Prohibit modification and deletion)
说明：
使用栈来判断给定的字符串中的括号是否匹配。先创建一个空栈，然后遍历字符串中的每个字符。如果是左括号字符，则压入栈中；如果是右括号字符，则与栈顶元素进行匹配。匹配成功则继续遍历，匹配失败则返回false。最后判断栈是否为空，如果为空则说明所有的括号都被匹配，返回true；否则，说明还有未匹配的括号，返回false
C++版本(由于C语言需要自己实现栈较为繁琐，此处使用C++)
#include <iostream>
#include <stack>
#include <string>
using namespace std;
bool isValid(string s) {
stack<char> stk; // 创建一个栈用于存储左括号字符
for (char c : s) {
if (c == '(' || c == '[' || c == '{') {
stk.push(c); // 如果是左括号字符，将其压入栈中
} else {
if (stk.empty()) {
return false; // 如果栈为空，说明缺少左括号，返回false
}
char top = stk.top(); /* 获取栈顶元素 */
stk.pop(); // 弹出栈顶元素
if (c == ')' && top != '(') {
return false; // 如果当前字符是右括号且与栈顶元素不匹配，返回false
}
if (c == ']' && top != '[') {
return false;
}
if (c == '}' && top != '{') {
return false;
}
}
}
return stk.empty(); // 最后判断栈是否为空，如果为空说明每个左括号都有匹配的右括号，则返回true，否则返回false
}
说明：
使用C++的标准库来实现栈，判断给定的字符串中的括号是否匹配。首先创建一个stack用于存储左括号字符。然后遍历字符串中的每个字符，如果是左括号字符，则将其压入栈中；如果是右括号字符，则与栈顶元素进行匹配。匹配成功则继续遍历，匹配失败则返回false。最后判断栈是否为空，如果为空则说明所有的括号都被匹配，返回true；否则，说明还有未匹配的括号，返回false。
Python3版本
class Solution:
def isValid(self, s: str) -> bool:
stack = [] # 创建一个栈用于存储左括号字符
brackets = {'(': ')', '[': ']', '{': '}'}
for char in s:
if char in brackets.keys(): # 如果是左括号字符，将其压入栈中
stack.append(char)
elif char in brackets.values(): # 如果是右括号字符
if not stack: # 如果栈为空，说明缺少左括号，返回False
return False
top = stack.pop() # 弹出栈顶元素
if char != brackets[top]: # 如果当前字符与栈顶元素不匹配，返回False
return False
return len(stack) == 0 # 判断栈是否为空，为空说明每个左括号都有匹配的右括号
说明：
创建一个列表作为栈来判断给定的字符串中的括号是否匹配。首先定义了一个字典brackets，用来存储左括号和右括号的对应关系。然后遍历字符串中的每个字符，如果是左括号字符，则将其压入栈中；如果是右括号字符，则和栈顶元素进行匹配。匹配成功则继续遍历，匹配失败则返回False。最后判断栈是否为空，如果为空则说明所有的括号都被匹配，返回True；否则，说明还有未匹配的括号，返回False
复杂度分析
- 时间复杂度：O(n)，其中 n 是字符串 s 的长度。
- 空间复杂度：O(n)，其中n为字符串的长度。在最坏情况下，所有的字符都是左括号，需要将其全部入栈，占用了O(n) 的空间。
方式二：递归法
思路
递归法解决括号有效性问题的思路是，从字符串的起始位置开始，不断地递归判断子字符串的有效性
代码实现
Java版本
public class Solution {
public boolean isValid(String s) {
// 调用递归辅助函数进行判断
return isValidHelper(s, 0, s.length() - 1);
}
private boolean isValidHelper(String s, int start, int end) {
// base case: 当起始位置等于结束位置时，返回该位置字符是否为左括号或右括号
if (start == end) {
return s.charAt(start) == '(' || s.charAt(start) == ')' ||
s.charAt(start) == '[' || s.charAt(start) == ']' ||
s.charAt(start) == '{' || s.charAt(start) == '}';
}
// 判断字符串两侧是否匹配，以及去掉最外侧字符后的子字符串是否有效
if (s.charAt(start) == '(') {
if (s.charAt(end) != ')') {
return false;
}
} else if (s.charAt(start) == '[') {
if (s.charAt(end) != ']') {
return false;
}
} else if (s.charAt(start) == '{') {
if (s.charAt(end) != '}') {
return false;
}
} else {
// 如果初始字符不是左括号，直接递归调用处理去掉首位字符的子字符串
return isValidHelper(s, start + 1, end - 1);
}
// 递归判断去掉左右括号后的子字符串是否有效
return isValidHelper(s, start + 1, end - 1);
}
}
说明：
isValidHelper 方法作为递归辅助函数用于实现递归逻辑。isValid 方法则是调用递归辅助函数并返回结果
C语言版本
#include <stdbool.h> // 包含 bool 类型定义的头文件
bool isValidHelper(char* s, int start, int end) {
// base case: 当起始位置等于结束位置时，返回该位置字符是否为左括号或右括号
if (start == end) {
return s[start] == '(' || s[start] == ')' ||
s[start] == '[' || s[start] == ']' ||
s[start] == '{' || s[start] == '}';
}
// 判断字符串两侧是否匹配，以及去掉最外侧字符后的子字符串是否有效
if (s[start] == '(') {
if (s[end] != ')') {
return false;
}
} else if (s[start] == '[') {
if (s[end] != ']') {
return false;
}
} else if (s[start] == '{') {
if (s[end] != '}') {
return false;
}
} else {
// 如果初始字符不是左括号，直接递归调用处理去掉首位字符的子字符串
return isValidHelper(s, start + 1, end - 1);
}
// 递归判断去掉左右括号后的子字符串是否有效
return isValidHelper(s, start + 1, end - 1);
}
bool isValid(char* s) {
// 调用递归辅助函数进行判断
return isValidHelper(s, 0, strlen(s) - 1);
}
说明
通过递归方式来判断给定的字符串 “s” 是否有效。isValidHelper 函数作为递归辅助函数用于实现递归逻辑。isValid 函数则是调用递归辅助函数并返回结果。需要注意的是，在C语言中，需要引入 <stdbool.h> 头文件来使用 bool 类型
Python3版本
def isValid(s: str) -> bool:
def isValidHelper(s: str, start: int, end: int) -> bool:
# Base case: 当起始位置等于结束位置时，返回该位置字符是否为左括号或右括号
if start == end:
return s[start] == '(' or s[start] == ')' or s[start] == '[' or s[start] == ']' or s[start] == '{' or s[start] == '}'
# 判断字符串两侧是否匹配，以及去掉最外侧字符后的子字符串是否有效
if s[start] == '(':
if s[end] != ')':
return False
elif s[start] == '[':
if s[end] != ']':
return False
elif s[start] == '{':
if s[end] != '}':
return False
else:
return isValidHelper(s, start + 1, end - 1)
# 递归判断去掉左右括号后的子字符串是否有效
return isValidHelper(s, start + 1, end - 1)
return isValidHelper(s, 0, len(s) - 1)
说明：
通过递归方式判断给定字符串 “s” 是否有效。如果有效，返回 True；如果无效，返回 False
复杂度分析
假设输入字符串的长度为 n。
- 时间复杂度： O(n)
在最坏情况下，需要递归访问字符串的每个字符，即递归的深度为字符串的长度 n。每次递归操作的时间复杂度为 O(1)。
因此，递归法的时间复杂度为 O(n)。 - 空间复杂度： O(n)
在递归的过程中，除了原始的字符串外，没有使用额外的空间。递归调用的栈空间的最大深度为 n/2（平均情况下为 n/4），即最多有 n/2 个递归调用帧。
因此，递归法的空间复杂度为 O(n)。
总结
| 对比点 | 递归法 | 栈解法 |
|---|---|---|
| 思路直观性 | 直观 | 相对复杂 |
| 递归深度问题 | 可能存在递归深度过大导致栈溢出的风险 | 无递归深度限制 |
| 利用系统调用栈 | 是 | 否 |
| 时间复杂度 | O(n) | O(n) |
| 空间复杂度 | O(n) | O(n) |
| 实现复杂性 | 相对简单 | 相对复杂 |
| 额外空间需求 | 无 | 有 |
相似题目
| 题目 | 链接 | 难度 |
|---|---|---|
| 有效的括号 | LeetCode-20 | 简单 |
| 最长有效括号 | LeetCode-32 | 困难 |
| 删除无效的括号 | LeetCode-301 | 困难 |
| 有效的括号字符串 | LeetCode-678 | 中等 |
| 括号的分数 | LeetCode-856 | 中等 |
