【力扣100】22.括号生成 || 为什么搜索几乎都是用深度优先遍历？

添加链接描述

class Solution:
    def generateParenthesis(self, n: int) -> List[str]:
        # 思路是根据左右括号剩余数量进行生成
        # 剩余左括号小于剩余右括号时，可以加左或者加右
        # 剩余左括号大于剩余右括号时，舍弃
        def backtrack(cur,left,right,res):
            if left==right==0:
                res.append(cur)
                return
            if left>right:
                return 
            if left>0:
                backtrack(cur+'(',left-1,right,res)
            if right>0:
                backtrack(cur+')',left,right-1,res)
        
        res=[]
        backtrack('',n,n,res)
        return res

思路：

1. 首先注意索然我这里函数名是backtrack但是这种解法并不包含回溯
2. 解题条件是，左右括号剩余的数量
3. 跳出递归的条件是：左右括号都用完或者剩余的左大于剩余的右
   
4. 剪枝条件已标红
5. 然后就可以在left>0和right>0的条件下，加入左右括号

广度优先遍历

为什么不推荐使用？广度优先与深度优先不同在哪？

• 广度优先遍历，得程序员自己编写结点类，显示使用队列这个数据结构。
• 深度优先遍历的时候，就可以直接使用系统栈，在递归方法执行完成的时候，系统栈顶就把我们所需要的状态信息直接弹出，而无须编写结点类和显示使用栈。
• 搜索几乎都是用深度优先遍历（回溯算法）。

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

public class Solution {

    class Node {
        /**
         * 当前得到的字符串
         */
        private String res;
        /**
         * 剩余左括号数量
         */
        private int left;
        /**
         * 剩余右括号数量
         */
        private int right;

        public Node(String str, int left, int right) {
            this.res = str;
            this.left = left;
            this.right = right;
        }
    }

    public List<String> generateParenthesis(int n) {
        List<String> res = new ArrayList<>();
        if (n == 0) {
            return res;
        }
        Queue<Node> queue = new LinkedList<>();
        queue.offer(new Node("", n, n));

        while (!queue.isEmpty()) {

            Node curNode = queue.poll();
            if (curNode.left == 0 && curNode.right == 0) {
                res.add(curNode.res);
            }
            if (curNode.left > 0) {
                queue.offer(new Node(curNode.res + "(", curNode.left - 1, curNode.right));
            }
            if (curNode.right > 0 && curNode.left < curNode.right) {
                queue.offer(new Node(curNode.res + ")", curNode.left, curNode.right - 1));
            }
        }
        return res;
    }
}