二叉树的最小深度：递归与迭代双解法详解

1. 问题描述

给定一个二叉树，找出其最小深度。最小深度是从根节点到最近叶子节点的最短路径上的节点数量。叶子节点是指没有子节点的节点。

示例1：

输入: root = [3,9,20,null,null,15,7]
    3
   / \
  9  20
    /  \
   15   7
输出: 2 (路径: 3→9)

示例2：

输入: root = [2,null,3,null,4,null,5,null,6]
    2
     \
      3
       \
        4
         \
          5
           \
            6
输出: 5 (路径: 2→3→4→5→6)

2. 解题思路

2.1 递归解法

1. 空树深度为0
2. 只有左/右子树时，计算单侧深度
3. 左右子树都存在时，取较小深度+1

2.2 迭代解法（BFS）

1. 使用队列进行层次遍历
2. 遇到第一个叶子节点立即返回当前深度
3. 效率更高，适合不平衡树

3. 代码实现

3.1 递归解法

#include <stdlib.h>
#include <limits.h>

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int minDepth(struct TreeNode* root) {
    if (root == NULL) return 0;
    
    // 只有右子树的情况
    if (root->left == NULL) {
        return minDepth(root->right) + 1;
    }
    // 只有左子树的情况
    if (root->right == NULL) {
        return minDepth(root->left) + 1;
    }
    
    // 左右子树都存在，取较小值
    int left = minDepth(root->left);
    int right = minDepth(root->right);
    return (left < right ? left : right) + 1;
}

3.2 迭代解法（BFS）

#include <stdlib.h>

typedef struct {
    struct TreeNode* node;
    int depth;
} QueueNode;

int minDepth(struct TreeNode* root) {
    if (root == NULL) return 0;
    
    QueueNode* queue = (QueueNode*)malloc(100000 * sizeof(QueueNode));
    int front = 0, rear = 0;
    
    queue[rear++] = (QueueNode){root, 1};
    
    while (front < rear) {
        QueueNode current = queue[front++];
        
        // 找到叶子节点
        if (current.node->left == NULL && current.node->right == NULL) {
            free(queue);
            return current.depth;
        }
        
        if (current.node->left != NULL) {
            queue[rear++] = (QueueNode){current.node->left, current.depth + 1};
        }
        if (current.node->right != NULL) {
            queue[rear++] = (QueueNode){current.node->right, current.depth + 1};
        }
    }
    
    free(queue);
    return 0; // 不会执行到这里
}

4. 代码解析

4.1 递归解法

• 基础情况：空树深度为0
• 单侧子树：继续递归计算单侧深度
• 双侧子树：取左右子树最小深度+1

4.2 迭代解法

• 使用队列实现BFS遍历
• 记录每个节点的深度
• 遇到第一个叶子节点立即返回当前深度
• 内存预先分配足够空间（根据题目约束）

5. 复杂度分析

6. 测试用例

测试用例1：

// 输入：
//     3
//    / \
//   9  20
//     /  \
//    15   7
// 预期输出: 2

测试用例2：

// 输入：
//    2
//     \
//      3
//       \
//        4
//         \
//          5
//           \
//            6
// 预期输出: 5

测试用例3：

// 输入: []
// 预期输出: 0

7. 关键点总结

✅ 最小深度定义：根节点到最近叶子节点的距离
✅ 递归终止条件：叶子节点的判断
✅ BFS优势：适合查找最短路径问题
✅ 边界处理：空树和单侧子树的情况

8. 扩展思考

• 如何修改算法求最大深度？
• 如何输出最小深度路径上的所有节点？
• 对于超大型树，哪种方法更优？

📌 总结：二叉树最小深度问题展示了递归和迭代两种解法的典型应用场景，BFS方法在寻找最短路径问题时尤为高效。掌握这两种方法对解决树结构相关问题很有帮助！