【力扣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. 跳出递归的条件是:左右括号都用完或者剩余的左大于剩余的右
    【力扣100】22.括号生成 || 为什么搜索几乎都是用深度优先遍历?_第1张图片
  4. 剪枝条件已标红
  5. 然后就可以在left>0right>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;
    }
}

你可能感兴趣的:(leetcode,深度优先,算法)