精华内容
下载资源
问答
  • 【Leetcode刷题篇】- Leetcode括号(有效括号、括号生成、最长有效括号) 括号 有效的括号 最长的有效括号 有效的 括号字符串 使括号有效的最少添加 有效括号的嵌套深度 反转每对括号间的子串 1.Leetcode 面试题...

    【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 。
    如果存在多个满足要求的答案,只需返回其中任意 一个 即可。

    img

    示例 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--;
            }
        }
    }
    
    展开全文
  • 【LeetCode】括号(有效括号、括号生成、最长有效括号······) 括号★★ LeetC面试题 08.09. 括号 【题目】括号。设计一种算法,打印n对括号的所有合法的(例如,开闭一一对应)组合。 说明:解集不能包含重复...


    括号★★

    LeetC面试题 08.09. 括号

    题目】括号。设计一种算法,打印n对括号的所有合法的(例如,开闭一一对应)组合。

    说明:解集不能包含重复的子集。

    示例

    输入:n = 3
    [
      "((()))",
      "(()())",
      "(())()",
      "()(())",
      "()()()"
    ]
    

    解题思路】使用递归来生成括号

    • 若在生成过程中右括号数量大于左括号数量则终止递归,或者左括号超过限定数目n则终止递归

    • 若左括号等于右括号等于n,则添加至结果集并且终止递归

    class Solution {
        List<String> res;
        public List<String> generateParenthesis(int n) {
            res = new ArrayList<String>();
            helper("", n, n);
            return res;
        }
        private void helper(String str, int le, int ri) {
            if(le > ri || le < 0) return;
            if(le == 0 && ri == 0) {
                res.add(new String(str));
                return;
            }
            helper(str + "(", le - 1, ri);
            helper(str + ")", le, ri - 1);
        }
    }
    

    有效的括号★

    LeetCode20. 有效的括号

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

    有效字符串需满足:

    • 左括号必须用相同类型的右括号闭合。
    • 左括号必须以正确的顺序闭合。

    注意空字符串可被认为是有效字符串

    示例

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

    解题思路

    方法一:使用栈模拟,遍历字符串

    • 若为左括号则入栈
    • 若为右括号则判断栈顶元素,若栈为空则返回false,若栈顶元素是与之对应的左括号则出栈,否则返回false
    • 最后若栈为空,则返回true,否则返回false
    class Solution {
        public boolean isValid(String s) {
            Stack<Character> stack = new Stack<Character>();
            for(char c : s.toCharArray()) {
                if(c == '(' || c == '[' || c == '{') {
                    stack.push(c);
                }else if(!stack.isEmpty()){
                    if(c == ')' && stack.peek() == '(' || 
                       c == ']' && stack.peek() == '[' ||
                       c == '}' && stack.peek() == '{') {
                        stack.pop();
                    }else {
                        return false;
                    }
                }else {
                    return false;
                }
            }
            return stack.isEmpty();
        }
    }
    

    方法二:使用String类的函数,用""替换所有的()[]{},最后判断字符串是否为空即可

    class Solution {
        public boolean isValid(String s) {
            while(!s.equals("")) {
                String str = s.replace("()", "").replace("[]", "").replace("{}", "");
                if(str.equals(s)) return false;
                s = str;
            }
            return true;
        }
    }
    

    最长有效括号★★★

    LeetCode32. 最长有效括号

    题目】给你一个只包含 '('')' 的字符串,找出最长有效(格式正确且连续)括号子串的长度。

    示例

    输入:s = ")()())"
    输出:4
    解释:最长有效括号子串是 "()()"
    

    解题思路】使用栈保存左括号下标,栈初始化为(-1)

    • 对于左括号,入栈对应下标
    • 对于右括号,出栈一个下标(表示出栈下标对应的左括号对应当前右括号)
      • 若栈为空,则说明不能构成有效括号,入栈当前下标(已遍历最右端不能构成有效括号的下标
      • 若栈不为空,则说明出栈下标对应为有效括号,更新res = Math.max(res, i - stack.peek())
    class Solution {
        public int longestValidParentheses(String s) {
            Stack<Integer> stack = new Stack<>();
            stack.push(-1);
            int res = 0;
            for(int i = 0; i < s.length(); i++) {
                if(s.charAt(i) == '(') {
                    stack.push(i);
                }else {
                    stack.pop();
                    if(stack.isEmpty()) {
                        stack.push(i);
                    }else {
                        res = Math.max(res, i - stack.peek());
                    }
                }
            }
            return res;
        }
    }
    

    有效的括号字符串★★

    LeetCode678. 有效的括号字符串

    题目】给定一个只包含三种字符的字符串:*,写一个函数来检验这个字符串是否为有效字符串。有效字符串具有如下规则:

    • 任何左括号 ( 必须有相应的右括号 )
    • 任何右括号 ) 必须有相应的左括号 (
    • 左括号 ( 必须在对应的右括号之前 )
    • *可以被视为单个右括号 ) ,或单个左括号 ( ,或一个空字符串
    • 一个空字符串也被视为有效字符串

    **注意:**字符串大小将在 [1,100] 范围内。

    示例

    ---输入: "()"
    输出: True
    ---输入: "(*))"
    输出: True
    

    解题思路

    方法一:双栈模拟,栈left保存左括号下标,栈star保存*下标,遍历字符串

    • 若当前字符为,则将下标i进栈left
    • 若当前字符为*,则将其下标i进栈start
    • 若当前字符为,若left不为空,优先配对出栈;若left为空且star不为空,则star出栈(表示当前出栈的下标处*可以表示一个左括号);若leftstar均为空,则没有与其配对的,返回false

    然后再来看leftstar中元素,此时表示*代替右括号来配对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>();
            for(int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
                if(c == '(') {
                    left.push(i);
                }else if(c == '*') {
                    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();
        }
    }
    

    方法二:使用两个变量lohi分别表示未匹配左括号的上界和下界

    class Solution {
        public boolean checkValidString(String s) {
            int lo = 0, hi = 0;    //未匹配左括号数量的范围
            for(char c : s.toCharArray()) {
                if(c == '(') {
                    lo++;
                    hi++;
                }else if(c == ')') {
                    lo = Math.max(0, lo - 1);
                    hi--;
                    if(hi < 0) return false;    //右括号多于左括号且不能匹配
                }else {
                    lo = Math.max(0, lo - 1);
                    hi++;
                }
            }
            return lo == 0;
        }
    }
    

    使括号有效的最少添加★★

    LeetCode使括号有效的最少添加

    题目】给定一个由 ‘(’ 和 ‘)’ 括号组成的字符串 S,我们需要添加最少的括号( ‘(’ 或是 ‘)’,可以在任何位置),以使得到的括号字符串有效。

    从形式上讲,只有满足下面几点之一,括号字符串才是有效的:

    • 它是一个空字符串,或者
    • 它可以被写成 AB (A 与 B 连接), 其中 A 和 B 都是有效字符串,或者
    • 它可以被写作 (A),其中 A 是有效字符串。

    给定一个括号字符串,返回为使结果字符串有效而必须添加的最少括号数。

    示例

    ---输入:"((("
    输出:3
    ---输入:"()))(("
    输出:4
    

    解题思路】最少添加至每个括号刚好匹配,即补充括号使不匹配的括号匹配

    方法一:遍历统计,使用countLeft标记左括号的个数,leastAdd记录添加个数

    • 若为左括号,则countLeft++
    • 若为右括号,若countLeft值大于0,则表示当前右括号有相应左括号与其配对,若countLeft值等于0,则表示没有与之对应的左括号配对,即需要添加一个(leastAdd++

    最后返回leastAdd + countLeft,此时countLeft表示没有与之配对的右括号的数量

    class Solution {
        public int minAddToMakeValid(String S) {
            int countLeft = 0;   //标记左括号的个数
            int leastAdd = 0;    //最少添加个数
            for(char c : S.toCharArray()){
                if(c == '(') {
                    countLeft++;
                }else {
                    if(countLeft == 0) {
                        leastAdd++;
                    }else {
                        countLeft--;
                    }
                }
            }   
            return leastAdd + countLeft;
        }
    }
    

    方法二:使用空字符串替换所有的(),最后剩余字符串的长度就是其未匹配的括号数量

    class Solution {
        public int minAddToMakeValid(String S) {
            while(S.contains("()")) {
                S = S.replace("()", "");
            }
            return S.length();
        }
    }
    

    有效括号的嵌套深度★★

    LeetCode有效括号的嵌套深度

    题目有效括号字符串 定义:对于每个左括号,都能找到与之对应的右括号,反之亦然。详情参见题末「有效括号字符串」部分。

    嵌套深度 depth 定义:即有效括号字符串嵌套的层数,depth(A) 表示有效括号字符串 A 的嵌套深度。详情参见题末**「嵌套深度」**部分。

    有效括号字符串类型与对应的嵌套深度计算方法如下图所示:

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hyBBnVS8-1610270685893)(…\LeetCode\great\有效括号嵌套深度.png)]

    给你一个「有效括号字符串」 seq,请你将其分成两个不相交的有效括号字符串,AB,并使这两个字符串的深度最小。

    • 不相交:每个 seq[i] 只能分给 AB 二者中的一个,不能既属于 A 也属于 B
    • AB 中的元素在原字符串中可以不连续。
    • A.length + B.length = seq.length
    • 深度最小:max(depth(A), depth(B)) 的可能取值最小。

    划分方案用一个长度为 seq.length 的答案数组 answer 表示,编码规则如下:

    • answer[i] = 0seq[i] 分给 A
    • answer[i] = 1seq[i] 分给 B

    如果存在多个满足要求的答案,只需返回其中任意 一个 即可。

    示例

    ----输入:seq = "(()())"
    输出:[0,1,1,1,1,0]
    ----输入: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 
    

    解题思路

    对于示例:( ( ) ( ( ) ) ( ) )
    嵌套深度:1 2 2 2 3 3 2 2 2 1
    分配方案:A B B B A A B B B A
    可见奇数的嵌套深度分配给A,偶数的嵌套深度分配给B
    
    class Solution {
        public int[] maxDepthAfterSplit(String seq) {
            int[] res = new int[seq.length()];
            int deep = 0;
            for(int i = 0; i < seq.length(); i++) {
                if(seq.charAt(i) == '(') {
                    deep++;
                    res[i] = deep & 1;
                }else {
                    res[i] = deep & 1;
                    deep--;
                }
            }
            return res;
        }
    }
    

    反转每对括号间的子串★★

    1190. 反转每对括号间的子串

    题目】给出一个字符串 s(仅含有小写英文字母和括号)。

    请你按照从括号内到外的顺序,逐层反转每对匹配括号中的字符串,并返回最终的结果。

    注意:您的结果中不应包含任何括号。

    提示:

    • 0 <= s.length <= 2000
    • s 中只有小写英文字母和括号
    • 我们确保所有括号都是成对出现的

    示例

    输入:s = "(u(love)i)"
    输出:"iloveu"
    ----------------------------------
    输入:s = "(ed(et(oc))el)"
    输出:"leetcode"
    

    解题思路

    每匹配一对括号就将对应区间内的字符反转

    class Solution {
        public String reverseParentheses(String s) {
            StringBuffer sb = new StringBuffer();
            char[] cs = s.toCharArray();
            Stack<Integer> stack = new Stack<>();
    
            for (int i = 0; i < cs.length; i++) {
                if (cs[i] == '(') {
                    stack.push(i);
                } else if (cs[i] == ')') {
                    reverse(cs, stack.pop() + 1, i - 1);
                }
            }
            for (char c : cs) {
                if (c != '(' && c != ')') {
                    sb.append(c);
                }
            }
    
            return sb.toString();
        }
    
        private void reverse(char[] cs, int le, int ri) {
            while (le < ri) {
                char c = cs[le];
                cs[le++] = cs[ri];
                cs[ri--] = c;
            }
        }
    }
    

    🎈

    2021/5/27新增题目“反转每对括号间的子串”

    展开全文
  • 有效括号Java编程 给定仅包含字符'(',')','{','}','['和']'的字符串s,请确定输入字符串是否有效。 输入字符串在以下情况下有效: 开括号必须用相同类型的括号封闭。 开括号必须以正确的顺序关闭。 范例1:...
  • 力扣-有效括号

    2020-08-14 10:05:31
    有效括号 给定一个只包括 ‘(’,’)’,’{’,’}’,’[’,’]’ 的字符串,判断字符串是否有效。 有效字符串需满足: 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为...

    有效括号

    给定一个只包括 ‘(’,’)’,’{’,’}’,’[’,’]’ 的字符串,判断字符串是否有效。
    有效字符串需满足:
    左括号必须用相同类型的右括号闭合。
    左括号必须以正确的顺序闭合。
    注意空字符串可被认为是有效字符串。
    示例 1:
    输入: “()”
    输出: true
    示例 2:
    输入: “()[]{}”
    输出: true
    示例 3:
    输入: “(]”
    输出: false
    示例 4:
    输入: “([)]”
    输出: false
    示例 5:
    输入: “{[]}”
    输出: true

    题解:
    显然,有效的一对括号可以通过“栈”来解决,栈的特点是:先入后出。那么在给定有效括号“()”“[]”“{}”的条件下,遇到一个左括号入栈 push,遇到对应右括号栈顶出栈 stack.pop()。遍历一遍后stack就仍为空。在迭代过程中,只要遇到不符合的括号就提前返回,以提升运行效率。
    在输入栈前先检验字符串 s 的长度,如果长度为奇数,那么一定是false。
    边界情况:

    1. 若栈为空,直接stack.pop() 会报错,可以初始化栈 stack = ?,配合哈希表key=’?’ value = ‘?’,如此,当栈为空时,也不会报错,而会正常返回false 。
    2. 若栈以左括号结尾,此时栈可以被完整遍历一遍,但会遗留一个未出栈的左括号,那么就返回一个 len(stack)==1
    class Solution:
        def isValid(self, s: str) -> bool:
            if len(s)%2 != 0:
                return false 
            dic = {'{': '}',  '[': ']', '(': ')', '?': '?'}
            stack = ['?']
            for c in s:
                if c in dic: stack.append(c)
                elif dic[stack.pop()] != c: 
               return false
            return len(stack) == 1
    """
    执行用时:32 ms, 在所有 Python3 提交中击败了97.69% 的用户
    内存消耗:13.5 MB, 在所有 Python3 提交中击败了96.12% 的用户
    """
    
    展开全文
  • 最长有效括号的长度

    2013-12-20 15:00:36
    给定只包含括号字符'('和 ')''的字符串,请找出最长的有效括号内子括号的长度。举几个例子如下: 例如对于"( ()",最长的有效的括号中的子字符串是"()" ,有效双括号数1个,故它的长度为 2。 再比如对于字符串") () ...
  • 栈与有效括号

    2020-12-21 23:14:31
    给定一个只包括 ‘(’,’)’,’{’,’}’,’[’,’]’ 的字符串,判断字符串是否有效有效字符串需满足: 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符...
  • Java实现 LeetCode 32 最长有效括号

    万次阅读 多人点赞 2020-02-13 16:18:15
    32. 最长有效括号 给定一个只包含 ‘(’ 和 ‘)’ 的字符串,找出最长的包含有效括号的子串的长度。 示例 1: 输入: “(()” 输出: 2 解释: 最长有效括号子串为 “()” 示例 2: 输入: “)()())” 输出: 4 解释: 最长...

    32. 最长有效括号

    给定一个只包含 ‘(’ 和 ‘)’ 的字符串,找出最长的包含有效括号的子串的长度。

    示例 1:

    输入: “(()”
    输出: 2
    解释: 最长有效括号子串为 “()”
    示例 2:

    输入: “)()())”
    输出: 4
    解释: 最长有效括号子串为 “()()”

    来源:力扣(LeetCode)
    链接:https://leetcode-cn.com/problems/longest-valid-parentheses
    著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

    class Solution {
        public int longestValidParentheses(String s) {
    	char[] chars = s.toCharArray();
    	return Math.max(calc(chars, 0, 1, chars.length, '('), calc(chars, chars.length -1, -1, -1, ')'));
    }
    private static int calc(char[] chars , int i ,  int flag,int end, char cTem){
    	int max = 0, sum = 0, currLen = 0,validLen = 0;
    	for (;i != end; i += flag) {
    		sum += (chars[i] == cTem ? 1 : -1);
            currLen ++;
    		if(sum < 0){
    			max = max > validLen ? max : validLen;
    			sum = 0;
    			currLen = 0;
                validLen = 0;
    		}else if(sum == 0){
                validLen = currLen;
            }
    	}
    	return max > validLen ? max : validLen;
    }
    }
    
    展开全文
  • 最长有效括号 给定一个只包含 ‘(’ 和 ‘)’ 的字符串,找出最长的包含有效括号的子串的长度。 示例 1: 输入: “(()” 输出: 2 解释: 最长有效括号子串为 “()” 示例 2: 输入: “)()())” 输出: 4 解释: 最长有效...
  • 括号字符串的最长有效长度
  • 给定一个只包括 '(',')','{','}','[',']' 的字符串,判断字符串是否有效有效字符串需满足: 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。(注意空字符串可被认为是有效字符串) ...
  • js代码-有效括号 Map

    2021-07-14 23:44:16
    js代码-有效括号 Map
  • PTA堆栈—有效括号判断 Alan最近眼神不好使,经常分不清楚括号,所以想请你帮忙,给定一个只包括 ‘(’,’)’,’{’,’}’,’[’,’]’ 的字符串,想让你帮忙编写程序确定括号是否都是正常闭合。 左括号必须用...
  • 这里考虑使用vector来实现匹配括号统计,并将成对括号存到vector中,使用栈可以实现同样的效果,这里使用vector在扩容上有一定性能损失; 该算法中将第一个括号字符均存入,在最后统计的时候根据最后一个字符来...
  • 有效括号 给定一个只包含字符'(' , ')' , '{' , '}' , '['和']'的字符串,确定输入字符串是否有效。 输入字符串在以下情况下有效: * 左括号必须由相同类型的括号封闭。 * 左括号必须以正确的顺序关闭。 * 请注意,...
  • c语言 有效括号

    2019-11-03 13:27:12
    给定一个只包括 ‘(’,’)’,’{’,’}’,’[’,’]’ 的字符串,判断字符串是否有效有效字符串需满足: 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符...
  • 数字 n 代表生成括号的对数,请你设计一个函数,用于能够生成所有可能的并且有效括号组合。 示例 示例 1: 输入:n = 3 输出:["((()))","(()())","(())()","()(())","()()()"] 示例 2: 输入:n = 1 输出:["()"]...
  • 32. 最长有效括号

    2018-11-01 20:43:48
    给定一个只包含 ‘(’ 和 ‘)’ 的字符串,找出最长的包含有效括号的子串的长度。 示例 1: 输入: “(()” 输出: 2 解释: 最长有效括号子串为 “()” 示例 2: 输入: “)()())” 输出: 4 解释: 最长有效括号子串为 “...
  • 最长有效括号字串

    2018-11-22 14:56:59
    给定一个只包含 '(' 和 ')' 的字符串,找出最长的包含有效括号的子串的长度。 示例 1: 输入: "(()" 输出: 2 解释: 最长有效括号子串为 "()" 示例 2: 输入: ")()())" 输出: 4 解释:...
  • 有效括号,刷过LeetCode的也许对这道题很熟悉。 1.开篇问题:有效的括号[1] 假如现在要你来解这道题,你会想到怎样的解法了? 这就要用到我们今天要讲的“栈”这种数据结构。带着这个问题,我们来学习今天的...
  • 给定一个只包含 ‘(’ 和 ‘)’ 的字符串,找出最长的包含有效括号的子串的长度。 示例 1: 输入: “(()” 输出: 2 解释: 最长有效括号子串为 “()” 示例 2: 示例 2: 输入: “)()())” 输出: 4 解释: 最长有效...
  • 力扣题库之判断是否为有效字符串 // 给定一个只包括 '(',')','{','}','[',']' 的字符串,判断字符串是否有效。 // 有效字符串需满足: // 左括号必须用相同类型的右括号闭合。 // 左括号必须以...
  • Leetcode 最长有效括号

    千次阅读 2021-01-27 23:03:08
    最长有效括号 题目描述: 给你一个只包含 '(' 和 ')' 的字符串,找出最长有效(格式正确且连续)括号子串的长度。 提示: 0 <= s.length <= 3*10^4 s[i] 为 '(' 或 ')' class Solution { private int[] ...
  • **有效括号字符串 定义:对于每个左括号,都能找到与之对应的右括号,反之亦然。详情参见题末「有效括号字符串」部分。 嵌套深度 depth 定义:即有效括号字符串嵌套的层数,depth(A) 表示有效括号字符串 A 的嵌套...
  • 有效括号生成

    万次阅读 2020-03-30 21:29:49
    有效括号生成题目描述题目分析回溯法   合法的括号匹配的问题之前已经讲解过了,现在再看一个括号生成的题目。 题目描述 给出 n 代表生成括号的对数,请你写出一个函数,使其能够生成所有可能的并且有效的括号...
  • 括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。 示例 1: 输入: "()" 输出: true 示例 2: 输入: "()[]{}" 输出: true 示例 3: 输入: "(]" 输出:...
  • 给定一个只包含 ‘(’ 和 ‘)’ 的字符串,找出最长的包含有效括号的子串的长度。 示例 1: 输入: "(()" 输出: 2 解释: 最长有效括号子串为 "()" 示例 2: 输入: ")()())" 输出: 4 解释: 最长有效括号子串为 "()()" ...
  • 有效括号的两种思路

    2018-11-09 22:20:13
    3、字符串的长度必须为偶数,否则不是有效括号 2、利用替换的思想 (1)如果() [] {} 成对出现,用”“替换,相当于删除 (2)剩下的,如果有成对的,继续替换 (3)重复length/2次后,用isEmpty()判断...
  • 7-3 有效括号判断(栈)

    2021-10-14 12:08:40
    Alan最近眼神不好使,经常分不清楚括号,所以想请你帮忙,给定一个只包括 '(',')','{','}','[',']' 的字符串,想让你帮忙编写程序确定括号是否都是正常闭合。 左括号必须用相同类型的右括号闭合。 左括号必须...
  • 最长有效括号 题目描述 给定一个只包含 ‘(’ 和 ‘)’ 的字符串,找出最长的包含有效括号的子串的长度。 示例 1: 输入: "(()" 输出: 2 解释: 最长有效括号子串为 "()" 示例 2: 输入: ")()())" 输出: 4 解释: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 212,615
精华内容 85,046
关键字:

有效的括号