二叉树深度优先搜索（DFS）原理与实现详解

1. 二叉树深度优先搜索（DFS）核心原理

深度优先搜索（DFS）是二叉树遍历中最基础也最重要的算法之一。与广度优先搜索（BFS）不同，DFS会沿着一条路径尽可能深入地探索，直到无法继续前进才回溯。这种"一条路走到黑"的特性，使其在解决某些特定问题时具有独特优势。

二叉树DFS的实现主要依靠递归，这是因为它完美契合了"分而治之"的思想——将大问题分解为小问题，用相同的方法处理子树。递归实现的DFS代码简洁优雅，通常不超过10行，但其中蕴含的思维却需要仔细体会。

新手常见误区：认为递归调用就是函数循环调用自己。实际上，递归的精髓在于将问题分解为更小的相同子问题，必须有明确的终止条件。

2. 二叉树DFS的三种经典遍历方式

2.1 前序遍历（Pre-order Traversal）

前序遍历的顺序是：根节点 → 左子树 → 右子树。这种"根在前"的特性使其非常适合用于复制树结构或序列化二叉树。

python复制def preorder(root):
    if not root:
        return
    print(root.val)  # 处理当前节点
    preorder(root.left)  # 递归左子树
    preorder(root.right)  # 递归右子树

实际应用场景：

• 表达式树求值
• 目录结构打印
• 二叉树的序列化

2.2 中序遍历（In-order Traversal）

中序遍历的顺序是：左子树 → 根节点 → 右子树。对二叉搜索树(BST)使用中序遍历，会得到一个升序序列，这是BST的重要性质。

python复制def inorder(root):
    if not root:
        return
    inorder(root.left)  # 递归左子树
    print(root.val)  # 处理当前节点
    inorder(root.right)  # 递归右子树

典型应用案例：

• 二叉搜索树验证
• 表达式树的中缀表示
• 排序数据输出

2.3 后序遍历（Post-order Traversal）

后序遍历的顺序是：左子树 → 右子树 → 根节点。这种"根在最后"的特性，使其适合用于需要先处理子节点再处理父节点的场景。

python复制def postorder(root):
    if not root:
        return
    postorder(root.left)  # 递归左子树
    postorder(root.right)  # 递归右子树
    print(root.val)  # 处理当前节点

常见使用场景：

• 计算二叉树高度
• 删除二叉树节点
• 表达式树的后缀表示

3. 递归实现的底层机制与优化

3.1 递归调用栈解析

每次递归调用都会在内存栈中压入一个新的栈帧，包含局部变量、参数和返回地址。对于深度为h的二叉树，递归DFS的空间复杂度为O(h)，最坏情况下（树退化为链表）达到O(n)。

递归调用栈示例（以前序遍历为例）：

1. 初始调用preorder(A)
2. 处理A，调用preorder(B)
3. 处理B，调用preorder(D)
4. 处理D（无子节点），返回
5. 回到B，调用preorder(E)
6. 处理E，返回
7. 回到A，调用preorder(C)
8. ...依次类推

3.2 尾递归优化可能性

严格来说，二叉树的DFS无法实现真正的尾递归优化，因为每个递归调用后还需要处理另一个递归调用。但在某些特殊情况下（如单边树），可以部分优化。

3.3 递归转迭代的实现方法

虽然递归实现简洁，但存在栈溢出风险。使用显式栈可以将其转换为迭代实现：

python复制def preorder_iterative(root):
    if not root:
        return
    stack = [root]
    while stack:
        node = stack.pop()
        print(node.val)
        if node.right:  # 右子节点先入栈
            stack.append(node.right)
        if node.left:   # 左子节点后入栈
            stack.append(node.left)

4. 二叉树DFS的进阶应用

4.1 路径总和问题

给定二叉树和目标和，判断是否存在根到叶子的路径和等于目标和。这是DFS的经典应用：

python复制def hasPathSum(root, target):
    if not root:
        return False
    if not root.left and not root.right:
        return root.val == target
    return (hasPathSum(root.left, target - root.val) or 
            hasPathSum(root.right, target - root.val))

4.2 二叉树序列化与反序列化

使用前序遍历实现二叉树的序列化：

python复制def serialize(root):
    if not root:
        return "None,"
    return str(root.val) + "," + serialize(root.left) + serialize(root.right)

def deserialize(data):
    def helper(queue):
        val = queue.popleft()
        if val == "None":
            return None
        node = TreeNode(int(val))
        node.left = helper(queue)
        node.right = helper(queue)
        return node
    queue = deque(data.split(","))
    return helper(queue)

4.3 最近公共祖先(LCA)问题

寻找二叉树中两个节点的最近公共祖先：

python复制def lowestCommonAncestor(root, p, q):
    if not root or root == p or root == q:
        return root
    left = lowestCommonAncestor(root.left, p, q)
    right = lowestCommonAncestor(root.right, p, q)
    if left and right:
        return root
    return left if left else right

5. 常见问题与调试技巧

5.1 递归终止条件错误

典型症状：栈溢出或结果不正确
解决方法：

1. 确保对空节点有明确处理
2. 检查叶子节点判断条件是否正确
3. 验证递归参数传递是否正确

5.2 遍历顺序混淆

常见错误：将前序、中序、后序的节点处理顺序混淆
记忆技巧：

• 前序：处理在递归调用前
• 中序：处理在两个递归调用之间
• 后序：处理在两个递归调用之后

5.3 路径记录问题

当需要记录完整路径时，常见错误是直接追加到列表导致所有分支共享同一个列表。正确做法是在每次递归时创建新列表或使用回溯：

python复制def binaryTreePaths(root):
    def dfs(node, path, res):
        if not node:
            return
        path += str(node.val)
        if not node.left and not node.right:
            res.append(path)
        else:
            path += "->"
            dfs(node.left, path, res)
            dfs(node.right, path, res)
    res = []
    dfs(root, "", res)
    return res

5.4 重复计算问题

在某些问题中（如计算二叉树高度），朴素递归会导致大量重复计算。可以使用记忆化优化：

python复制memo = {}
def treeHeight(root):
    if not root:
        return 0
    if root in memo:
        return memo[root]
    height = 1 + max(treeHeight(root.left), treeHeight(root.right))
    memo[root] = height
    return height

6. 性能分析与优化策略

6.1 时间复杂度分析

对于平衡二叉树：

• 时间复杂度：O(n)，每个节点访问一次
• 空间复杂度：O(log n)，递归栈深度

对于最坏情况（退化为链表）：

• 空间复杂度：O(n)

6.2 剪枝优化技巧

在某些搜索问题中，可以通过提前终止不必要的递归分支来优化：

python复制def findTarget(root, k):
    def dfs(node, seen, target):
        if not node:
            return False
        complement = target - node.val
        if complement in seen:
            return True
        seen.add(node.val)
        return dfs(node.left, seen, target) or dfs(node.right, seen, target)
    return dfs(root, set(), k)

6.3 并行化可能性

对于大规模二叉树，可以考虑并行处理左右子树：

python复制from concurrent.futures import ThreadPoolExecutor

def parallel_traversal(root):
    if not root:
        return
    with ThreadPoolExecutor() as executor:
        left_future = executor.submit(parallel_traversal, root.left)
        right_future = executor.submit(parallel_traversal, root.right)
        print(root.val)  # 前序处理
        left_future.result()
        right_future.result()

7. 与其他算法的对比与结合

7.1 DFS与BFS的比较

7.2 与回溯算法的关系

回溯算法本质上是DFS的一种应用，区别在于：

• 回溯会"撤销选择"（回溯步骤）
• 标准DFS通常不涉及状态回退

典型回溯模式：

python复制def backtrack(path, choices):
    if meet_condition:
        record_result()
        return
    for choice in choices:
        make_choice(choice)
        backtrack(path, new_choices)
        undo_choice(choice)  # 关键回溯步骤

7.3 与动态规划的结合

在某些树形DP问题中，DFS用于后序遍历计算子问题结果：

python复制def rob(root):
    def dfs(node):
        if not node:
            return (0, 0)  # (偷当前节点最大值，不偷当前节点最大值)
        left = dfs(node.left)
        right = dfs(node.right)
        rob_current = node.val + left[1] + right[1]
        not_rob = max(left) + max(right)
        return (rob_current, not_rob)
    return max(dfs(root))

8. 实际工程中的应用案例

8.1 文件系统遍历

模拟Unix的find命令实现：

python复制def find_files(root_dir, pattern):
    results = []
    def dfs(node):
        if os.path.isfile(node):
            if re.match(pattern, os.path.basename(node)):
                results.append(node)
        elif os.path.isdir(node):
            for child in os.listdir(node):
                dfs(os.path.join(node, child))
    dfs(root_dir)
    return results

8.2 DOM树操作

前端框架中的虚拟DOM diff算法常基于DFS：

javascript复制function diff(oldNode, newNode) {
    if (!oldNode && !newNode) return null
    if (!oldNode) return { type: 'INSERT', node: newNode }
    if (!newNode) return { type: 'REMOVE' }
    if (oldNode.type !== newNode.type) {
        return { 
            type: 'REPLACE',
            oldNode,
            newNode
        }
    }
    
    const patches = []
    const childrenPatches = []
    const len = Math.max(oldNode.children.length, newNode.children.length)
    
    for (let i = 0; i < len; i++) {
        childrenPatches[i] = diff(
            oldNode.children[i],
            newNode.children[i]
        )
    }
    
    if (Object.keys(patches).length > 0 || 
        childrenPatches.some(p => p !== null)) {
        return {
            type: 'UPDATE',
            patches,
            childrenPatches
        }
    }
    return null
}

8.3 游戏决策树搜索

棋类游戏的AI决策：

python复制def minimax(node, depth, maximizingPlayer):
    if depth == 0 or node.is_terminal():
        return node.evaluate()
    
    if maximizingPlayer:
        value = -float('inf')
        for child in node.get_children():
            value = max(value, minimax(child, depth-1, False))
        return value
    else:
        value = float('inf')
        for child in node.get_children():
            value = min(value, minimax(child, depth-1, True))
        return value

9. 可视化工具与调试技巧

9.1 递归调用可视化

使用Python的sys模块获取递归深度：

python复制import sys

sys.setrecursionlimit(10000)  # 调整递归深度限制

def dfs(node, depth=0):
    print(f"当前深度: {depth}, 节点: {node.val if node else 'None'}")
    if not node:
        return
    dfs(node.left, depth+1)
    dfs(node.right, depth+1)

9.2 图形化展示遍历过程

使用Graphviz可视化二叉树遍历：

python复制from graphviz import Digraph

def visualize_traversal(root):
    dot = Digraph()
    stack = [(root, False)]
    while stack:
        node, visited = stack.pop()
        if not node:
            continue
        if visited:
            dot.node(str(id(node)), label=str(node.val), 
                    style='filled', fillcolor='lightgrey')
        else:
            dot.node(str(id(node)), label=str(node.val))
            stack.append((node, True))
            stack.append((node.right, False))
            stack.append((node.left, False))
            if node.left:
                dot.edge(str(id(node)), str(id(node.left)))
            if node.right:
                dot.edge(str(id(node)), str(id(node.right)))
    return dot

9.3 调试打印技巧

添加缩进显示递归层级：

python复制def print_tree(root, indent=0):
    if not root:
        print(" " * indent + "None")
        return
    print(" " * indent + str(root.val))
    print_tree(root.left, indent + 4)
    print_tree(root.right, indent + 4)

10. 扩展与变种算法

10.1 莫里斯遍历（Morris Traversal）

空间复杂度O(1)的中序遍历算法：

python复制def morris_inorder(root):
    current = root
    while current:
        if not current.left:
            print(current.val)
            current = current.right
        else:
            # 找到当前节点的前驱节点
            predecessor = current.left
            while predecessor.right and predecessor.right != current:
                predecessor = predecessor.right
            
            if not predecessor.right:
                predecessor.right = current  # 建立线索
                current = current.left
            else:
                predecessor.right = None  # 拆除线索
                print(current.val)
                current = current.right

10.2 迭代深化DFS（IDDFS）

结合BFS和DFS优点的混合算法：

python复制def iddfs(root, max_depth):
    for depth in range(max_depth + 1):
        if dls(root, depth):
            return True
    return False

def dls(node, depth):
    if depth == 0 and node.is_target:
        return True
    if depth > 0:
        for child in node.children:
            if dls(child, depth - 1):
                return True
    return False

10.3 双向DFS

从起点和终点同时搜索，适用于已知目标状态的情况：

python复制def bidirectional_dfs(start, target):
    forward_visited = {start}
    backward_visited = {target}
    forward_stack = [start]
    backward_stack = [target]
    
    while forward_stack and backward_stack:
        # 前向搜索一步
        current = forward_stack.pop()
        for neighbor in current.neighbors:
            if neighbor in backward_visited:
                return True  # 找到连接
            if neighbor not in forward_visited:
                forward_visited.add(neighbor)
                forward_stack.append(neighbor)
        
        # 后向搜索一步
        current = backward_stack.pop()
        for neighbor in current.neighbors:
            if neighbor in forward_visited:
                return True  # 找到连接
            if neighbor not in backward_visited:
                backward_visited.add(neighbor)
                backward_stack.append(neighbor)
    
    return False

11. 系统设计中的应用

11.1 依赖解析

构建系统的依赖关系解析（如Makefile、npm）：

python复制def resolve_dependencies(root):
    resolved = set()
    visiting = set()
    
    def dfs(node):
        if node in resolved:
            return
        if node in visiting:
            raise Exception("循环依赖 detected")
        
        visiting.add(node)
        for dependency in node.dependencies:
            dfs(dependency)
        
        visiting.remove(node)
        resolved.add(node)
        print(f"处理: {node.name}")
    
    dfs(root)

11.2 垃圾回收标记-清除算法

标记阶段本质上是DFS遍历：

python复制def garbage_collect(roots):
    marked = set()
    
    def mark(node):
        if not node or node in marked:
            return
        marked.add(node)
        for ref in node.references:
            mark(ref)
    
    # 标记阶段
    for root in roots:
        mark(root)
    
    # 清除阶段
    for obj in heap:
        if obj not in marked:
            free(obj)

11.3 网络爬虫实现

限制深度的网页爬虫：

python复制def crawl(start_url, max_depth):
    visited = set()
    
    def dfs(url, depth):
        if depth > max_depth or url in visited:
            return
        visited.add(url)
        try:
            html = download(url)
            links = extract_links(html)
            for link in links:
                dfs(link, depth + 1)
        except Exception as e:
            print(f"Error crawling {url}: {e}")
    
    dfs(start_url, 0)
    return visited

12. 面试常见问题解析

12.1 二叉树的最大深度

python复制def maxDepth(root):
    if not root:
        return 0
    return 1 + max(maxDepth(root.left), maxDepth(root.right))

12.2 验证二叉搜索树

python复制def isValidBST(root, min_val=float('-inf'), max_val=float('inf')):
    if not root:
        return True
    if not (min_val < root.val < max_val):
        return False
    return (isValidBST(root.left, min_val, root.val) and 
            isValidBST(root.right, root.val, max_val))

12.3 二叉树展开为链表

python复制def flatten(root):
    def dfs(node):
        if not node:
            return None
        left_tail = dfs(node.left)
        right_tail = dfs(node.right)
        
        if node.left:
            left_tail.right = node.right
            node.right = node.left
            node.left = None
        
        return right_tail or left_tail or node
    
    dfs(root)

12.4 二叉树的直径

python复制def diameterOfBinaryTree(root):
    diameter = 0
    
    def depth(node):
        nonlocal diameter
        if not node:
            return 0
        left = depth(node.left)
        right = depth(node.right)
        diameter = max(diameter, left + right)
        return 1 + max(left, right)
    
    depth(root)
    return diameter

13. 性能基准测试

13.1 递归 vs 迭代性能对比

测试代码示例：

python复制import timeit

# 递归实现
def recursive_dfs(node):
    if node:
        recursive_dfs(node.left)
        recursive_dfs(node.right)

# 迭代实现
def iterative_dfs(root):
    stack = [root]
    while stack:
        node = stack.pop()
        if node:
            stack.append(node.right)
            stack.append(node.left)

# 测试
setup = '''
from __main__ import recursive_dfs, iterative_dfs, create_large_tree
root = create_large_tree(10000)
'''

print("递归DFS:", timeit.timeit('recursive_dfs(root)', setup=setup, number=100))
print("迭代DFS:", timeit.timeit('iterative_dfs(root)', setup=setup, number=100))

典型结果（单位：秒）：

• 递归DFS：3.21
• 迭代DFS：2.87

13.2 不同遍历顺序的性能差异

测试三种遍历方式的性能差异通常很小，因为每个节点都只访问一次。主要区别在于：

• 函数调用开销
• 缓存局部性影响
• 特定硬件架构优化

14. 多语言实现对比

14.1 Java实现

java复制// 前序遍历
public void preorder(TreeNode root) {
    if (root == null) return;
    System.out.println(root.val);
    preorder(root.left);
    preorder(root.right);
}

// 迭代实现
public void preorderIterative(TreeNode root) {
    if (root == null) return;
    Deque<TreeNode> stack = new ArrayDeque<>();
    stack.push(root);
    while (!stack.isEmpty()) {
        TreeNode node = stack.pop();
        System.out.println(node.val);
        if (node.right != null) stack.push(node.right);
        if (node.left != null) stack.push(node.left);
    }
}

14.2 C++实现

cpp复制// 中序遍历
void inorder(TreeNode* root) {
    if (!root) return;
    inorder(root->left);
    std::cout << root->val << std::endl;
    inorder(root->right);
}

// 迭代实现
void inorderIterative(TreeNode* root) {
    stack<TreeNode*> s;
    TreeNode* curr = root;
    while (curr || !s.empty()) {
        while (curr) {
            s.push(curr);
            curr = curr->left;
        }
        curr = s.top();
        s.pop();
        cout << curr->val << endl;
        curr = curr->right;
    }
}

14.3 JavaScript实现

javascript复制// 后序遍历
function postorder(root) {
    if (!root) return;
    postorder(root.left);
    postorder(root.right);
    console.log(root.val);
}

// 迭代实现
function postorderIterative(root) {
    if (!root) return;
    const stack = [root];
    const output = [];
    while (stack.length) {
        const node = stack.pop();
        output.push(node.val);
        if (node.left) stack.push(node.left);
        if (node.right) stack.push(node.right);
    }
    while (output.length) {
        console.log(output.pop());
    }
}

15. 现代编程语言特性应用

15.1 Python生成器实现惰性遍历

python复制def dfs_generator(root):
    if not root:
        return
    yield root.val  # 前序位置
    yield from dfs_generator(root.left)
    yield from dfs_generator(root.right)

# 使用示例
for value in dfs_generator(root):
    process(value)

15.2 Java Stream API实现

java复制public Stream<TreeNode> preorderStream(TreeNode root) {
    if (root == null) return Stream.empty();
    return Stream.concat(
        Stream.concat(
            Stream.of(root),
            preorderStream(root.left)
        ),
        preorderStream(root.right)
    );
}

// 使用示例
preorderStream(root).forEach(node -> System.out.println(node.val));

15.3 JavaScript异步DFS

javascript复制async function asyncDFS(root, processNode) {
    if (!root) return;
    await processNode(root);
    await asyncDFS(root.left, processNode);
    await asyncDFS(root.right, processNode);
}

// 使用示例
asyncDFS(root, async node => {
    const data = await fetchData(node.id);
    console.log(data);
});

16. 数学理论基础

16.1 递归关系式

二叉树DFS的时间复杂度通常可以表示为递归关系式：
T(n) = 2T(n/2) + O(1)

根据主定理(Master Theorem)，这个递归式的解为O(n)。

16.2 卡特兰数应用

n个节点的不同二叉树形态数为卡特兰数：
Cₙ = (1/(n+1))(2n choose n)

这与DFS的调用次数有密切关系。

16.3 归纳法证明正确性

使用数学归纳法证明DFS的正确性：

1. 基本情况：空树或单节点树显然正确
2. 归纳假设：假设对左右子树DFS正确
3. 归纳步骤：根据遍历顺序组合，整个树的遍历正确

17. 历史发展与演变

17.1 递归概念的起源

递归在数学中的使用可以追溯到19世纪的递归函数理论，但作为编程概念，是在20世纪50年代随着Lisp语言的发明而普及。

17.2 DFS算法的提出

深度优先搜索最早由法国数学家Charles Pierre Trémaux在19世纪提出，用于解决迷宫问题。

17.3 现代编程语言中的优化

现代编译器/解释器对递归的优化：

• 尾调用优化(TCO)
• 调用栈缓存
• 尾递归转换为迭代

18. 内存管理与优化

18.1 递归深度限制

大多数编程语言默认递归深度限制：

• Python：1000
• Java：约8000（取决于栈大小）
• C/C++：取决于栈大小（通常MB级别）

18.2 栈大小调整方法

在需要处理深度递归时调整栈大小：

• Python：sys.setrecursionlimit(10000)
• C++：编译时指定栈大小-Wl,--stack=16777216
• Java：-Xss4m设置栈大小为4MB

18.3 堆栈分离技巧

将递归数据移到堆上以减少栈压力：

python复制class Frame:
    def __init__(self, node, stage):
        self.node = node
        self.stage = stage  # 0: before left, 1: after left, 2: after right

def dfs_heap(root):
    stack = [Frame(root, 0)]
    while stack:
        frame = stack[-1]
        if not frame.node:
            stack.pop()
            continue
        
        if frame.stage == 0:
            # 前序处理
            print(frame.node.val)
            frame.stage = 1
            stack.append(Frame(frame.node.left, 0))
        elif frame.stage == 1:
            # 中序处理
            frame.stage = 2
            stack.append(Frame(frame.node.right, 0))
        else:
            # 后序处理
            stack.pop()

19. 异常处理与边界情况

19.1 栈溢出处理

检测和防止栈溢出：

python复制import sys

def safe_dfs(root, max_depth=1000):
    sys.setrecursionlimit(max_depth + 100)
    try:
        return dfs(root)
    except RecursionError:
        print(f"达到最大递归深度 {max_depth}")
        return None

19.2 循环引用检测

在可能存在循环引用的图中：

python复制def dfs_detect_cycle(root):
    visited = set()
    path = set()
    
    def helper(node):
        if node in path:
            raise Exception("检测到循环引用")
        if node in visited:
            return
        
        visited.add(node)
        path.add(node)
        
        for child in [node.left, node.right]:
            if child:
                helper(child)
        
        path.remove(node)
    
    helper(root)

19.3 大数处理

当节点值非常大时的处理技巧：

python复制from functools import lru_cache

@lru_cache(maxsize=None)
def expensive_computation(node):
    if not node:
        return 0
    # 假设这是非常耗时的计算
    return node.val + expensive_computation(node.left) + expensive_computation(node.right)

20. 测试用例设计

20.1 常规测试用例

python复制import unittest

class TestTreeDFS(unittest.TestCase):
    def setUp(self):
        #       1
        #      / \
        #     2   3
        #    / \
        #   4   5
        self.tree = TreeNode(1)
        self.tree.left = TreeNode(2)
        self.tree.right = TreeNode(3)
        self.tree.left.left = TreeNode(4)
        self.tree.left.right = TreeNode(5)
    
    def test_preorder(self):
        expected = [1, 2, 4, 5, 3]
        result = []
        preorder(self.tree, result.append)
        self.assertEqual(result, expected)
    
    def test_inorder(self):
        expected = [4, 2, 5, 1, 3]
        result = []
        inorder(self.tree, result.append)
        self.assertEqual(result, expected)
    
    def test_postorder(self):
        expected = [4, 5, 2, 3, 1]
        result = []
        postorder(self.tree, result.append)
        self.assertEqual(result, expected)

20.2 边界测试用例

python复制class TestEdgeCases(unittest.TestCase):
    def test_empty_tree(self):
        result = []
        preorder(None, result.append)
        self.assertEqual(result, [])
    
    def test_single_node(self):
        tree = TreeNode(1)
        result = []
        preorder(tree, result.append)
        self.assertEqual(result, [1])
    
    def test_left_heavy(self):
        # 1
        #  \
        #   2
        #    \
        #     3
        tree = TreeNode(1)
        tree.right = TreeNode(2)
        tree.right.right = TreeNode(3)
        result = []
        inorder(tree, result.append)
        self.assertEqual(result, [1, 2, 3])
    
    def test_right_heavy(self):
        #     3
        #    /
        #   2
        #  /
        # 1
        tree = TreeNode(3)
        tree.left = TreeNode(2)
        tree.left.left = TreeNode(1)
        result = []
        postorder(tree, result.append)
        self.assertEqual(result, [1, 2, 3])

20.3 性能测试用例

python复制class TestPerformance(unittest.TestCase):
    def test_large_tree(self):
        # 构建一个深度为1000的右倾树
        root = TreeNode(0)
        current = root
        for i in range(1, 1000):
            current.right = TreeNode(i)
            current = current.right
        
        # 测试不会栈溢出
        result = []
        inorder(root, result.append)
        self.assertEqual(len(result), 1000)
    
    def test_balanced_tree(self):
        from random import randint
        
        def build_balanced(size):
            if size == 0:
                return None
            left_size = randint(0, size-1)
            node = TreeNode(randint(1, 100))
            node.left = build_balanced(left_size)
            node.right = build_balanced(size - 1 - left_size)
            return node
        
        tree = build_balanced(10000)
        # 测试能处理大规模数据
        result = []
        preorder(tree, lambda x: result.append(x))
        self.assertTrue(len(result) > 0)