输出指定括号对数的所有可能组合

最新推荐文章于 2024-07-22 01:12:24 发布
最新推荐文章于 2024-07-22 01:12:24 发布
阅读量398 收藏 2
点赞数 1
文章标签： 数据结构与算法 python
原文链接：https://my.oschina.net/wangmengjun/blog/760138
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

如果给出一个正整数，表示一共有多少对括号，如何输出所有括号可能的组合？

比如：给出的括号对数为3， 则所有括号的组合有如下几种：

()()()
()(())
(())()
(()())
((()))

为了解决这个问题，本文采用两种方式来完成。

  • 广度优先搜索的方式
  • 深度优先搜索的方式

接下来，我们一起来看看广度优先搜索和深度优先搜索的思想和具体实现。

广度优先搜索方式

思想

所谓广度优先搜索的方式就是尽可能早的先输出完整的括号对(), 也就是当输出一个左括号 '(' ， 尽可能先输出一个右括号 ‘)’ 。

比如要输出括号对数是2对的所有可能，先输出的结果是()(), 而不是(())。

()()
(())

 

我们可以定义三个值来完成递归调用：

currParentheses 当前存放的括号组合情况
leftCount 剩余左括号数
rightCount 剩余右括号数

 

什么时候输出一个候选结果？

当剩余左括号数和剩余右括号数都为0的时候。

左括号'('和右括号'')输出的时机？

广度优先搜索的目的是先得到完整的括号对(), 这种情况下需要需要考虑如下两种情况：

  • 输出右边括号')'的时机：如果剩余的右括号数大于剩余的左括号数，那么意味着之前已经有一个左括号输出了，在这种情况下，将当前存放的括号组合情况添加一个右括号，然后剩余右边括号数减1，然后继续递归调用。
  • 输出左边括号'('的时机：如果剩余的左括号数leftCount大于0，则当前存放的括号组合情况添加一个左括号'(', 然后剩余左括号数减1，然后继续递归调用。

有了上述的思想，我们可以很容易写出相应的程序来。具体代码如下：

代码实现


    /**
     * 广度优先搜索递归函数
     * @param currParentheses 当前存放的括号组合情况
     * @param leftCount 剩余左括号数
     * @param rightCount 剩余右括号数
     */
    private void bfsRecu(String currParentheses, int leftCount, int rightCount) {

        /**
         * 结束条件：
         * 当剩余括号数和剩余右括号数都为0时，表示括号已经用完，直接输出就可以打印出一种情况
         */
        if (leftCount == 0 && rightCount == 0) {
            System.out.println(currParentheses);
        }

        /**
         * 广度优先搜索的目的是先得到完整的括号对(), 这种情况下
         * 需要检查剩余的右括号数是否大于剩余的左括号数，如果大于则表示已经有一个左括号输出了，
         * 在这种情况下，将当前存放的括号组合情况添加一个右括号，然后右边括号数减1，然后递归调用
         * 
         */
        if (rightCount > leftCount) {
            bfsRecu(currParentheses + ')', leftCount, rightCount - 1);
        }

        /**
         * 如果还有剩余左括号数，则将当前存放的括号组合情况添加一个左括号，然后剩余左边括号数减1，然后递归调用即可
         */
        if (leftCount > 0) {
            bfsRecu(currParentheses + '(', leftCount - 1, rightCount);
        }
    }

 

有了广度优先搜索的递归调用函数，广度优先搜索方法就可以调用递归函数即可。当前存放括号内容的变量为空。

    /**
     * 广度搜索方式打印括号组合数字
     * @param parentheseCount 括号对数
     */
    public void bfs(int parentheseCount) {
        if (parentheseCount < 1) {
            throw new IllegalArgumentException("括号对数不能小于1");
        }
        bfsRecu("", parentheseCount, parentheseCount);
    }

 

深度优先搜索方式

思想

深度优先搜索的思路和广度优先搜索类似，唯一的区别就是先输出完整的括号对，还是先尽可能多地输出左括号。

广度优先搜索的方式就是尽可能早的先输出完整的括号对(), 也就是当输出一个左括号 '(' ， 尽可能先输出一个右括号 ‘)’ 。

深度优先搜索的方式就是尽可能早的先输出左括号('', 也就是如果剩余左括号数大于0的时，先获取左边括号'('。

比如要输出括号对数是2对的所有可能，先输出的结果是(()), 而不是()()。

(())
()()

 

和广度优先搜索一样，我们依旧可以定义三个值来完成递归调用：

currParentheses 当前存放的括号组合情况
leftCount 剩余左括号数
rightCount 剩余右括号数

 

什么时候输出一个候选结果？

当剩余左括号数和剩余右括号数都为0的时候。

左括号'('和右括号'')输出的时机？

深度优先搜索的目的是先尽可能多的得到左括号'(', 这种情况下需要需要考虑如下两种情况：

  • 输出左边括号'('的时机：如果剩余的左括号数leftCount大于0，则当前存放的括号组合情况添加一个左括号'(', 然后剩余左括号数减1，然后继续递归调用。
  • 输出右边括号')'的时机：如果剩余的右括号数大于剩余的左括号数，那么意味着之前已经有一个左括号输出了，在这种情况下，将当前存放的括号组合情况添加一个右括号，然后剩余右边括号数减1，然后继续递归调用。

有了上述的思想，我们可以很容易写出相应的程序来。具体代码如下：

代码实现

    /**
     * 深度优先搜索递归方法
     * @param currParentheses 当前存放的括号组合情况
     * @param leftCount 剩余左括号数
     * @param rightCount 剩余右括号数
     */
    private void dfsRecu(String currParentheses, int leftCount, int rightCount) {

        /**
         * 结束条件：
         * 当剩余括号数和剩余右括号数都为0时，表示括号已经用完，直接输出就可以打印出一种情况
         */
        if (leftCount == 0 && rightCount == 0) {
            System.out.println(currParentheses);
        }

        /**
         * 深度优先搜索的目的是尽可能先获取左边括号, 这种情况下, 如果剩余左括号数大于0，则
         * 将当前存放的括号组合情况添加一个左括号，然后剩余左边括号数减1，然后递归调用
         * 
         */
        if (leftCount > 0) {
            dfsRecu(currParentheses + '(', leftCount - 1, rightCount);
        }

        /**
         * 检查剩余的右括号数是否大于剩余的左括号数，如果大于，
         * 则将当前存放的括号组合情况添加一个右括号，然后右边括号数减1，然后递归调用
         * 
         */
        if (rightCount > leftCount) {
            dfsRecu(currParentheses + ')', leftCount, rightCount - 1);
        }


    }

有了深度优先搜索的递归调用函数，深度优先搜索方法就可以调用递归函数即可。

    /**
     * 深度搜索方式打印括号组合数字
     * @param parentheseCount 括号对数
     */
    public void dfs(int parentheseCount) {
        if (parentheseCount < 1) {
            throw new IllegalArgumentException("括号对数不能小于1");
        }
        dfsRecu("", parentheseCount, parentheseCount);
    }

 

完整代码和测试结果

完整代码

/**
 * @author wangmengjun
 */
public class ParenthesesPrinter {

    /**
     * 广度搜索方式打印括号组合数字
     * @param parentheseCount 括号对数
     */
    public void bfs(int parentheseCount) {
        if (parentheseCount < 1) {
            throw new IllegalArgumentException("括号对数不能小于1");
        }
        bfsRecu("", parentheseCount, parentheseCount);
    }
    

    /**
     * 广度优先搜索递归函数
     * @param currParentheses 当前存放的括号组合情况
     * @param leftCount 剩余左括号数
     * @param rightCount 剩余右括号数
     */
    private void bfsRecu(String currParentheses, int leftCount, int rightCount) {

        /**
         * 结束条件：
         * 当剩余括号数和剩余右括号数都为0时，表示括号已经用完，直接输出就可以打印出一种情况
         */
        if (leftCount == 0 && rightCount == 0) {
            System.out.println(currParentheses);
        }

        /**
         * 广度优先搜索的目的是先得到完整的括号对(), 这种情况下
         * 需要检查剩余的右括号数是否大于剩余的左括号数，如果大于则表示已经有一个左括号输出了，
         * 在这种情况下，将当前存放的括号组合情况添加一个右括号，然后右边括号数减1，然后递归调用
         * 
         */
        if (rightCount > leftCount) {
            bfsRecu(currParentheses + ')', leftCount, rightCount - 1);
        }

        /**
         * 如果还有剩余左括号数，则将当前存放的括号组合情况添加一个左括号，然后剩余左边括号数减1，然后递归调用即可
         */
        if (leftCount > 0) {
            bfsRecu(currParentheses + '(', leftCount - 1, rightCount);
        }
    }
    
    
    /**
     * 深度搜索方式打印括号组合数字
     * @param parentheseCount 括号对数
     */
    public void dfs(int parentheseCount) {
        if (parentheseCount < 1) {
            throw new IllegalArgumentException("括号对数不能小于1");
        }
        dfsRecu("", parentheseCount, parentheseCount);
    }
    
    /**
     * 深度优先搜索递归方法
     * @param currParentheses 当前存放的括号组合情况
     * @param leftCount 剩余左括号数
     * @param rightCount 剩余右括号数
     */
    private void dfsRecu(String currParentheses, int leftCount, int rightCount) {

        /**
         * 结束条件：
         * 当剩余括号数和剩余右括号数都为0时，表示括号已经用完，直接输出就可以打印出一种情况
         */
        if (leftCount == 0 && rightCount == 0) {
            System.out.println(currParentheses);
        }

        /**
         * 深度优先搜索的目的是尽可能先获取左边括号, 这种情况下, 如果剩余左括号数大于0，则
         * 将当前存放的括号组合情况添加一个左括号，然后剩余左边括号数减1，然后递归调用
         * 
         */
        if (leftCount > 0) {
            dfsRecu(currParentheses + '(', leftCount - 1, rightCount);
        }

        /**
         * 检查剩余的右括号数是否大于剩余的左括号数，如果大于，
         * 则将当前存放的括号组合情况添加一个右括号，然后右边括号数减1，然后递归调用
         * 
         */
        if (rightCount > leftCount) {
            dfsRecu(currParentheses + ')', leftCount, rightCount - 1);
        }
    }
}

 

测试代码和结果

/**
 * @author wangmengjun
 *
 */
public class Main {

    public static void main(String[] args) {
        ParenthesesPrinter example = new ParenthesesPrinter();
        for (int i = 2; i <= 5; i++) {
            System.out.println(String.format("广度优先搜索, %d对括号所有的可能组合,", i));
            example.bfs(i);
            System.out.println();
            System.out.println(String.format("深度优先搜索, %d对括号所有的可能组合,", i));
            example.dfs(i);
            System.out.println();
        }
    }

}

运行结果如下：

广度优先搜索, 2对括号所有的可能组合,
()()
(())

深度优先搜索, 2对括号所有的可能组合,
(())
()()

广度优先搜索, 3对括号所有的可能组合,
()()()
()(())
(())()
(()())
((()))

深度优先搜索, 3对括号所有的可能组合,
((()))
(()())
(())()
()(())
()()()

广度优先搜索, 4对括号所有的可能组合,
()()()()
()()(())
()(())()
()(()())
()((()))
(())()()
(())(())
(()())()
(()()())
(()(()))
((()))()
((())())
((()()))
(((())))

深度优先搜索, 4对括号所有的可能组合,
(((())))
((()()))
((())())
((()))()
(()(()))
(()()())
(()())()
(())(())
(())()()
()((()))
()(()())
()(())()
()()(())
()()()()

广度优先搜索, 5对括号所有的可能组合,
()()()()()
()()()(())
()()(())()
()()(()())
()()((()))
()(())()()
()(())(())
()(()())()
()(()()())
()(()(()))
()((()))()
()((())())
()((()()))
()(((())))
(())()()()
(())()(())
(())(())()
(())(()())
(())((()))
(()())()()
(()())(())
(()()())()
(()()()())
(()()(()))
(()(()))()
(()(())())
(()(()()))
(()((())))
((()))()()
((()))(())
((())())()
((())()())
((())(()))
((()()))()
((()())())
((()()()))
((()(())))
(((())))()
(((()))())
(((())()))
(((()())))
((((()))))

深度优先搜索, 5对括号所有的可能组合,
((((()))))
(((()())))
(((())()))
(((()))())
(((())))()
((()(())))
((()()()))
((()())())
((()()))()
((())(()))
((())()())
((())())()
((()))(())
((()))()()
(()((())))
(()(()()))
(()(())())
(()(()))()
(()()(()))
(()()()())
(()()())()
(()())(())
(()())()()
(())((()))
(())(()())
(())(())()
(())()(())
(())()()()
()(((())))
()((()()))
()((())())
()((()))()
()(()(()))
()(()()())
()(()())()
()(())(())
()(())()()
()()((()))
()()(()())
()()(())()
()()()(())
()()()()()

 

转载于:https://my.oschina.net/wangmengjun/blog/760138

weixin_34278190
关注
华为OD最新面试手撕代码：括号生成
zf169_com的博客
06-24 629
数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
《C/C++等级考试（1~8级）历届真题解析》专栏总目录
热门推荐
人生就是一个不断学习的过程
08-28 2万+
中国电子学会《全国青少年软件编程等级考试》C/C++编程（1~8级）历届真题解析。订阅后可阅读专栏内所有真题解析，真题持续更新中！
有效括号对数（递推法）
qq_46110834的博客
05-01 358
介绍了一种十分简单的查找有效括号序列的方法。
数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
m0_47575628的博客
11-17 1489
/* 示例： 输入：n = 3 输出：[ "((()))", "(()())", "(())()", "()(())", "()()()" ] */ vector<string>generateParenthesis(intn){ vector<string>res; func(res,"",0,0,n); ...
括号的全部有效组合
weixin_30335353的博客
09-29 164
输入n，打印n对括号中的全部有效组合。（即左右括号正确的配对）。 分析：水题，直接切。 1 /* 2 ID: y1197771 3 PROG: test 4 LANG: C++ 5 */ 6 #include<bits/stdc++.h> 7 #define pb push_back 8 #define FOR(i, n) for (in...
经典问题——输出n对括号的所有组合
dianshu1593的博客
01-20 1050
问题 n对括号有多少种合法的组合，比如两对括号可以有两种：（）（）和（（）） 思路 问题等价为：在一个字符串中包含两种字符：'('和')'，他们出现的次数都为n，并且任何时候'('出现的次数总是大于或等于')'出现的次数。 解决方案：（递归） n表示括号对数，l表示已有括号个数，r表示已有右括号个数若r = n,则输出结果若l < r,不可能若l = r,则加上左括号若l...
打印n对括号的全部有效组合（左右括号正确匹配）Java实现
diqingshui9034的博客
05-09 1155
一、问题导出 今天在做算法题目的时候遇到了一道左右括号匹配的问题，问题如下： 二、问题思考 （1）这种要列出全部可能性的题目很容易想到由小到大去发现规律，用递归或者暴力搜索。 首先1的情况，一个括号只有一种可能，就是（） 接着想2的情况，加个括号，可以在1的基础上加在其左边、右边或者包围住1，即()()、()()、(())去掉重复就剩下两种 同理3在2的基础上，都加上左边...
java中输出值保留四位小数_Java核心技术笔记分享------第一章 java程序基础概述...
weixin_39657825的博客
11-22 1372
菜鸡大学生，现在正在自学java，此篇是我用来记录分享我的笔记。刚开始学习，笔记会有很多地方不严谨不完整，所以将会持续更新与完善。欢迎大佬指正！欢迎大佬指正！欢迎大佬指正！JAVA语言基础知识一、java运行核心机制1、java是运行在一个java虚拟机上——jvm。jvm是一个虚拟的机，具有指令集并使用不同的储存区域。负责执行指令，管理数据、内存、寄存器。2、对于不同的平台，有不同的虚拟机。3、...
2024 年 100 大数据科学面试问答
最新发布
gongdiwudu的专栏
07-22 2435
数据科学是一个快速发展的领域，它正在改变组织根据数据理解和做出决策的方式。因此，公司越来越多地寻求聘请数据科学家来帮助他们理解数据并推动业务成果。这导致了对数据科学家的高需求，这些职位的竞争可能非常激烈。为了帮助您准备数据科学面试，我们编制了一份您可能遇到的前 100 个数据科学面试问题列表。
第3-5课：24 点计算器
oRbIt 的专栏
09-22 761
24 点游戏是一个很有意思的数字游戏，也是一道常见的算法面试题。题目是这样的：任给四个数（为了便于人们心算或口算，一般都是小于 10 的数），对四个数字用各种组合进行加、减、乘、除四则运算，看看结果是否能等于 24？对于面试题来说，这是一个典型的穷举类型算法问题。这个题目比较有意思的地方是它除了要对数字组合进行枚举，还要对四个运算符进行组合。这一课我们要介绍的方法有点特殊，它没有简单地使用穷...
Leetcode 22.生成括号对数
kexinxin1的博客
12-22 287
生成括号对数 给出n代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且有效的括号组合。 例如，给出n =3，生成结果为： [ "((()))", "(()())", "(())()", "()(())", "()()()" ] 1 class Solution { 2 public List<...
打印出所有可能的括号组合
AlgorithmEngine
09-10 1073
以下为递归方法实现 #include #include #define N 3 void print(int left, int right, std::vector v) { if (left == right && left == N) { for (size_t i = 0; i < v.size(); i++) {
编译原理—括号的对数
LY_624的专栏
04-20 1205
.lex文件 %{ /* * 输入一符号串，若合法，则输出括号的对数 */ #include void yyerror(char*); %} %% [()\n] { return *yytext; } . {return a;} %% int yywrap(void) { return 1; } .y文件
括号生成（列出所有括号的搭配情况）(回溯)
疯狂的蜗牛
07-14 497
//数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。 // // 示例： // // 输入：n = 3 //输出：[ // “((()))”, // “(()())”, // “(())()”, // “()(())”, // “()()()” // ] // // Related Topics 字符串 回溯算法 //思路1：数学归纳法 代码不好写 //思路2：递归、深度优先遍历DFS
合法括号（java）
lianggege88的博客
04-13 739
问题描述： 输入括号对数，输出所有的合法组合，比如输入1，输出"()"，输入3，输出"()()(), (()()), ()(()), (())(), ((()))"。 思路分析： 面对这种问题，其实一开始想通如何使用递归是不太容易的，不妨一一列举出来，发现其相应的规律。可以发现，增加一个单位，则都会在其上一个集合上每个元素的左面、右面和整体的外面加上一层括号。那么就会产生大量的重复元素，所以，我们...
C++括号匹配问题
Moon_yao的博客
03-28 1101
用char型栈，解决括号匹配问题
【力扣算法18】之 22. 括号生成 python
全栈若城,专注知识分享
07-20 1003
本文介绍了一个用于生成有效括号组合的函数。通过回溯法，我们可以生成所有可能的括号组合，并通过限制左括号和右括号的数量，确保生成的组合都是有效的。文章详细介绍了解题思路和代码实现。首先，定义一个函数generateParenthesis，接收一个整数参数n，表示生成括号的对数。然后，创建一个空列表result，用于保存结果。接着，调用辅助函数backtrack来生成括号组合。在backtrack函数中，通过递归和判断条件，生成所有可能的并且有效的括号组合。最后，将结果列表result返回作为最终输出。
20. 有效的括号(C++实现)
呋喃吖的博客
11-02 502
题目 题目链接：20. 有效的括号 思路 有效括号的匹配问题和栈的出入问题很相似且匹配； 括号匹配问题可以从最内部的括号开始匹配：比如[ ( { } ) ]从 { } 开始匹配，只要是成对，表示匹配成功，继续匹配下一对！ 可是关键问题是，如何找到最里面的括号对匹配呢？ 我们可以用栈来帮助我们，当我们遍历字符串 s 时候，碰到左括号就入栈，碰到右括号就拿出栈的左括号来匹配，这样不就可以成对匹配了嘛！ 并且由于栈是后进先出的结构，也就解决了从字符串内部括号匹配的问题！ 思路： 1.遍历字符串，遇到左括号入
合法括号
qq_50089743的博客
03-20 352
/** * 1.输出合法的括号组合 * 输入括号对数 * 输出所有合法组合 * 输入:3 * 输出:()()(),((())),(()()),()(()),(())(), * 2.判断一个字符串是否合法 */ public class _合法括号 { public static void main(String[] args) { _合法括号 obj = new _合法括号(); Set<String> parenthesis = obj.parenthesi...
n代表括号的对数，生成所有可能的有效括号的组合，用python实现
07-12
可以使用递归的方法来生成所有可能的有效括号组合。具体的实现如下： ```python def generate_valid_parentheses(n): result = [] backtrack(result, "", 0, 0, n) return result def backtrack(result, ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值