【Leetcode刷题篇】- Leetcode括号(有效括号、括号生成、最长有效括号)
- 括号
- 有效的括号
- 最长的有效括号
- 有效的 括号字符串
- 使括号有效的最少添加
- 有效括号的嵌套深度
- 反转每对括号间的子串
1.Leetcode 面试题08.09 括号
括号。设计一种算法,打印n对括号的所有合法的(例如,开闭一一对应)组合。
说明:解集不能包含重复的子集。
例如,给出 n = 3,生成结果为:
[
“((()))”,
“(()())”,
“(())()”,
“()(())”,
“()()()”
]
【解题思路】使用递归来生成括号
- 若在生成过程中右括号数量大于左括号数量则终止递归,或者左括号超过限定数目
n则终止递归- 若左括号等于右括号等于
n,则添加至结果集并且终止递归
class Solution {
// 结果
List<String> res;
public List<String> generateParenthesis(int n) {
res = new ArrayList<>();
// 回溯
dfs("",n,n);
return res;
}
public void dfs(String str,int left,int right){
// 如果左括号剩余的数量大于了
if(left>right || left<0){
return;
}
//符合条件
if(left==0 && right==0){
res.add(new String(str));
return;
}
// 继续
dfs(str+"(",left-class Solution {
// 结果
List<String> res;
public List<String> generateParenthesis(int n) {
res = new ArrayList<>();
// 回溯
dfs("",n,n);
return res;
}
public void dfs(String str,int left,int right){
// 如果左括号剩余的数量大于了
if(left>right || left<0){
return;
}
//符合条件
if(left==0 && right==0){
res.add(new String(str));
return;
}
// 继续
dfs(str+"(",left-1,right);
dfs(str+")",left,right-1);
}
}1,right);
dfs(str+")",left,right);
}
}
2.Leetcode20有效的括号
给定一个只包括 ‘(’,’)’,’{’,’}’,’[’,’]’ 的字符串 s ,判断字符串是否有效。
有效字符串需满足:
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
示例 1:
输入:s = “()”
输出:true
示例 2:
输入:s = “()[]{}”
输出:true
示例 3:
输入:s = “(]”
输出:false
有效字符串需满足:
- 左括号必须用相同类型的右括号闭合。
- 左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串
class Solution {
public boolean isValid(String s) {
//字典来解题
Map<Character,Character> dict = new HashMap<>();
dict.put('(',')');
dict.put('{','}');
dict.put('[',']');
// 继续
Stack<Character> stack = new Stack<>();
// 继续
char[] arr = s.toCharArray();
for(int i=0;i<arr.length;i++){
if(dict.containsKey(arr[i])){
//入栈
stack.push(arr[i]);
}else{
if(stack.isEmpty()||arr[i]!=dict.get(stack.peek())){
return false;
}
stack.pop();
}
}
return stack.isEmpty();
}
}
3.Leetcode32 最长有效括号
给你一个只包含 '(' 和 ')' 的字符串,找出最长有效(格式正确且连续)括号子串的长度。
示例 1:
输入:s = "(()"
输出:2
解释:最长有效括号子串是 "()"
示例 2:
输入:s = ")()())"
输出:4
解释:最长有效括号子串是 "()()"
示例 3:
输入:s = ""
输出:0
【解题思路】使用栈保存左括号下标,栈初始化为(-1)
对于左括号,入栈对应下标
对于右括号,出栈一个下标(表示出栈下标对应的左括号对应当前右括号)
- 若栈为空,则说明不能构成有效括号,入栈当前下标(已遍历最右端不能构成有效括号的下标)
- 若栈不为空,则说明出栈下标对应为有效括号,更新res = Math.max(res, i - stack.peek())
class Solution {
public int longestValidParentheses(String s) {
char[] arr = s.toCharArray();
int len = arr.length;
// 栈
Stack<Integer> stack = new Stack<>();
stack.push(-1);
// 将结果
int res = 0;
for(int i=0;i<arr.length;i++){
if(arr[i]=='('){
stack.push(i);
}else{
//右括号
stack.pop();
//判断为空则更新
if(stack.isEmpty()){
stack.push(i);
}else{
//不为空则记录
res = Math.max(res,i-stack.peek());
}
}
}
return res;
}
}
4.Leetcode678 有效的括号字符串
给定一个只包含三种字符的字符串:( ,) 和 *,写一个函数来检验这个字符串是否为有效字符串。有效字符串具有如下规则:
任何左括号 ( 必须有相应的右括号 )。
任何右括号 ) 必须有相应的左括号 ( 。
左括号 ( 必须在对应的右括号之前 )。
- 可以被视为单个右括号 ) ,或单个左括号 ( ,或一个空字符串。
一个空字符串也被视为有效字符串。
示例 1:
输入: “()”
输出: True
示例 2:
输入: “(*)”
输出: True
示例 3:
输入: “(*))”
输出: True
【解题思路】
方法:双栈模拟,栈left保存左括号下标,栈star保存*下标,遍历字符串
- 若当前字符为(,则将下标i进栈left
- 若当前字符为*,则将其下标i进栈start*
- 若当前字符为),若left不为空,优先配对出栈;若left为空且star不为空,则star出栈(表示当前出栈的下标处可以表示一个左括号);若left和star均为空,则没有与其配对的,返回false
然后再来看left和star中元素,此时表示*代替右括号来配对left栈中剩余的左括号
- 若left栈顶元素大于star栈顶元素,表示*下标处于左括号下标左边,返回false
- 否则均出栈一个元素,表示配对
最后若left不为空,表示剩余左括号无法配对,返回false,若为空,返回true
class Solution {
public boolean checkValidString(String s) {
// 两个栈模拟
Stack<Integer> left = new Stack<Integer>();
Stack<Integer> star = new Stack<Integer>();
char[] arr = s.toCharArray();
int len = arr.length;
for(int i=0;i<len;i++){
// 判断
if(arr[i]=='('){
left.push(i);
}else if(arr[i]=='*'){
star.push(i);
}else{
if(!left.isEmpty()){
left.pop();
}else if(!star.isEmpty()){
star.pop();
}else{
return false;
}
}
}
//都不为空再次判断
while(!left.isEmpty()&&!star.isEmpty()){
if(left.pop()>star.pop()){
return false;
}
}
return left.isEmpty();
}
}
5.Leetcode921 使括号有效的最少添加
给定一个由 ‘(’ 和 ‘)’ 括号组成的字符串 S,我们需要添加最少的括号( ‘(’ 或是 ‘)’,可以在任何位置),以使得到的括号字符串有效。
从形式上讲,只有满足下面几点之一,括号字符串才是有效的:
它是一个空字符串,或者
它可以被写成 AB (A 与 B 连接), 其中 A 和 B 都是有效字符串,或者
它可以被写作 (A),其中 A 是有效字符串。
给定一个括号字符串,返回为使结果字符串有效而必须添加的最少括号数。
示例 1:
输入:"())"
输出:1
示例 2:
输入:"((("
输出:3
class Solution {
public int minAddToMakeValid(String s) {
//栈辅助
Stack<Character> stack = new Stack<>();
char[] arr = s.toCharArray();
int len = arr.length;
int op = 0;
for(int i=0;i<len;i++){
//判断
if(arr[i]=='('){
stack.push('(');
}else{
if(stack.isEmpty()){
op++;
}else{
//判断
stack.pop();
}
}
}
return op+stack.size();
}
}
6.Leetcode1111 有效括号的嵌套深度
有效括号字符串 定义:对于每个左括号,都能找到与之对应的右括号,反之亦然。详情参见题末「有效括号字符串」部分。
嵌套深度 depth 定义:即有效括号字符串嵌套的层数,depth(A) 表示有效括号字符串 A 的嵌套深度。详情参见题末「嵌套深度」部分。
有效括号字符串类型与对应的嵌套深度计算方法如下图所示:
给你一个「有效括号字符串」 seq,请你将其分成两个不相交的有效括号字符串,A 和 B,并使这两个字符串的深度最小。
不相交:每个 seq[i] 只能分给 A 和 B 二者中的一个,不能既属于 A 也属于 B 。
A 或 B 中的元素在原字符串中可以不连续。
A.length + B.length = seq.length
深度最小:max(depth(A), depth(B)) 的可能取值最小。
划分方案用一个长度为 seq.length 的答案数组 answer 表示,编码规则如下:
answer[i] = 0,seq[i] 分给 A 。
answer[i] = 1,seq[i] 分给 B 。
如果存在多个满足要求的答案,只需返回其中任意 一个 即可。

示例 1:
输入:seq = “(()())”
输出:[0,1,1,1,1,0]
示例 2:
输入:seq = “()(())()”
输出:[0,0,0,1,1,0,1,1]
解释:本示例答案不唯一。
按此输出 A = “()()”, B = “()()”, max(depth(A), depth(B)) = 1,它们的深度最小。
像 [1,1,1,0,0,1,1,1],也是正确结果,其中 A = “()()()”, B = “()”, max(depth(A), depth(B)) = 1 。
class Solution {
public int[] maxDepthAfterSplit(String seq) {
char[] arr = seq.toCharArray();
int len = arr.length;
// 结果
int[] res = new int[len];
// 辅助
int d = 0;
// 继续
for(int i=0;i<len;i++){
//判断
if(arr[i]=='('){
++d;
res[i] = d%2;
}else{
res[i] = d%2;
--d;
}
}
return res;
}
}
7.Leetcode1190 反转每对括号间的子串
给出一个字符串 s(仅含有小写英文字母和括号)。
请你按照从括号内到外的顺序,逐层反转每对匹配括号中的字符串,并返回最终的结果。
注意,您的结果中 不应 包含任何括号。
示例 1:
输入:s = “(abcd)”
输出:“dcba”
示例 2:
输入:s = “(u(love)i)”
输出:“iloveu”
解释:先反转子字符串 “love” ,然后反转整个字符串。
示例 3:
输入:s = “(ed(et(oc))el)”
输出:“leetcode”
解释:先反转子字符串 “oc” ,接着反转 “etco” ,然后反转整个字符串。
class Solution {
public String reverseParentheses(String s) {
// 栈
Stack<Integer> stack = new Stack<>();
char[] arr = s.toCharArray();
int len = arr.length;
for(int i=0;i<len;i++){
// 判断
if(arr[i]=='('){
stack.push(i);
}else if(arr[i]==')'){
reverse(arr,stack.pop(),i);
}
}
StringBuilder res = new StringBuilder();
for(int i=0;i<arr.length;i++){
if(arr[i]!='('&&arr[i]!=')'){
res.append(arr[i]);
}
}
return res.toString();
}
//反转
public void reverse(char[] arr,int i,int j){
while(i<=j){
char temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
i++;
j--;
}
}
}
707



被折叠的 条评论
为什么被折叠?



