Python 深搜，广搜

一、深度优先搜索

深度优先搜索(Depth-First Search)是一种用于遍历或搜索树或图的算法，它沿着树的深度遍历节点，尽可能深地搜索树的分支。

算法特点

• 使用栈(递归或显式栈)实现
• 优先探索最新发现的节点
• 内存消耗相对较小(取决于树的深度)
• 适合寻找所有解或路径问题

典型应用

• 二叉树的前序/中序/后序遍历
• 图的连通性检测
• 拓扑排序
• 寻找所有路径
• 解决迷宫问题

示例：二叉树的中序遍历

from typing import List, Optional

class TreeNode:
    """二叉树节点"""
    def __init__(self, val: int = 0,
                 left: Optional['TreeNode'] = None,
                 right: Optional['TreeNode'] = None):
        self.val = val
        self.left = left
        self.right = right

# ---------------- 构造树（LeetCode 层序输入格式） ----------------
def build_tree(nums: List[Optional[int]]) -> Optional[TreeNode]:
    if not nums or nums[0] is None:
        return None
    root = TreeNode(nums[0])
    q = [root]
    idx = 1
    while q and idx < len(nums):
        node = q.pop(0)
        if idx < len(nums) and nums[idx] is not None:
            node.left = TreeNode(nums[idx])
            q.append(node.left)
        idx += 1
        if idx < len(nums) and nums[idx] is not None:
            node.right = TreeNode(nums[idx])
            q.append(node.right)
        idx += 1
    return root

# ---------------- 两种中序遍历实现 ----------------
# 1) 递归
def inorder_recursive(root: Optional[TreeNode]) -> List[int]:
    if not root:
        return []
    return inorder_recursive(root.left) + [root.val] + inorder_recursive(root.right)

# 2) 迭代（显式栈）
def inorder_iterative(root: Optional[TreeNode]) -> List[int]:
    res, stack = [], []
    cur = root
    while cur or stack:
        while cur:
            stack.append(cur)
            cur = cur.left
        cur = stack.pop()
        res.append(cur.val)
        cur = cur.right
    return res

# ---------------- 主程序：读取输入 → 输出 ----------------
if __name__ == '__main__':
    # 示例输入：层序遍历结果，None 表示空节点
    # 对应树：    5
    #        /     \
    #      3        8
    #    /   \    /   \
    #   2    4   7     9
    #  / \  / \ / \   / \
    # N  N N  N N  N N   1
    nums = [5, 3, 8, 2, 4, 7, 9, None, None, None, None, None, None, None, 1]

    root = build_tree(nums)

    rec = inorder_recursive(root)
    itr = inorder_iterative(root)

    print("输入（层序）:", nums)
    print("递归中序   :", rec)
    print("迭代中序   :", itr)

# 输入（层序）: [5, 3, 8, 2, 4, 7, 9, None, None, None, None, None, None, None, 1]
# 递归中序   : [2, 3, 4, 5, 7, 8, 9, 1]
# 迭代中序   : [2, 3, 4, 5, 7, 8, 9, 1]

二、广度优先搜索算法

基本概念

• 使用队列实现
• 优先探索最早发现的节点
• 内存消耗相对较大(取决于树的宽度)
• 适合寻找最短路径问题

典型应用

• 二叉树的层序遍历
• 无权图的最短路径
• 社交网络中的好友推荐
• 网页爬虫
• 寻找最近邻或最小步数解

示例：二叉树的层序遍历

from typing import List, Optional
from collections import deque

class TreeNode:
    def __init__(self, val: int = 0,
                 left: 'Optional[TreeNode]' = None,
                 right: 'Optional[TreeNode]' = None):
        self.val = val
        self.left = left
        self.right = right

# ---------- 根据层序列表构建二叉树 ----------
def build_tree(level: List[Optional[int]]) -> Optional[TreeNode]:
    if not level or level[0] is None:
        return None
    root = TreeNode(level[0])
    q = deque([root])
    idx = 1
    while q and idx < len(level):
        node = q.popleft()
        # 左孩子
        if idx < len(level) and level[idx] is not None:
            node.left = TreeNode(level[idx])
            q.append(node.left)
        idx += 1
        # 右孩子
        if idx < len(level) and level[idx] is not None:
            node.right = TreeNode(level[idx])
            q.append(node.right)
        idx += 1
    return root

# ---------- 层序遍历 ----------
def level_order(root: Optional[TreeNode]) -> List[List[int]]:
    if not root:
        return []
    res = []
    q = deque([root])
    while q:
        level_size = len(q)
        cur = []
        for _ in range(level_size):
            node = q.popleft()
            cur.append(node.val)
            if node.left:
                q.append(node.left)
            if node.right:
                q.append(node.right)
        res.append(cur)
    return res

# ---------- 测试 ----------
if __name__ == "__main__":
    # 示例输入：层序列表（None 表示空节点）
    level_input = [3, 9, 20, None, None, 15, 7]
    root = build_tree(level_input)
    print("输入层序:", level_input)
    print("层序遍历输出:", level_order(root))

# 输入层序: [3, 9, 20, None, None, 15, 7]
# 层序遍历输出: [[3], [9, 20], [15, 7]]