二叉树的最小深度揭秘：算法精髓

闲谈

2024-02-09 01:12:34

深入探索二叉树的最小深度

在计算机科学的世界中，理解数据结构的特性至关重要，尤其是像二叉树这样的非线性结构。其中一个关键特性是确定二叉树的最小深度，即从树的根节点到最近叶节点的最短路径上的节点数量。

算法概览

有两种主要算法可以确定二叉树的最小深度：

递归算法： 这种方法通过递归遍历二叉树来计算最小深度。对于每个节点，算法递归地计算其左右子树的最小深度，然后将其自身深度设为 1 加上较小深度。
深度优先搜索（DFS）： DFS 算法通过使用栈来遍历二叉树。它从根节点开始，依次访问其子节点，并将未访问的子节点推入栈中。当一个节点的所有子节点都被访问后，它将从栈中弹出，并返回其最小深度。

算法步骤

递归算法：

如果根节点为空，返回 0（代表没有深度）。
如果根节点没有子节点，返回 1（代表深度为 1）。
否则，计算左右子树的最小深度。
返回 1 加上较小深度。

深度优先搜索：

初始化栈并将其推入根节点。
只要栈不为空，就执行以下步骤：
- 弹出栈顶节点。
- 如果节点没有子节点，则返回栈的深度。
- 否则，将未访问的子节点推入栈中。

代码示例

Python：

def min_depth_recursively(root):
    if not root:
        return 0
    if not root.left and not root.right:
        return 1
    if not root.left:
        return 1 + min_depth_recursively(root.right)
    if not root.right:
        return 1 + min_depth_recursively(root.left)
    return 1 + min(min_depth_recursively(root.left), min_depth_recursively(root.right))


def min_depth_DFS(root):
    if not root:
        return 0
    stack = [root]
    depth = 0
    while stack:
        current = stack.pop()
        depth += 1
        if not current.left and not current.right:
            return depth
        if current.right:
            stack.append(current.right)
        if current.left:
            stack.append(current.left)

C++：

int min_depth_recursively(TreeNode* root) {
    if (!root) return 0;
    if (!root->left && !root->right) return 1;
    if (!root->left) return 1 + min_depth_recursively(root->right);
    if (!root->right) return 1 + min_depth_recursively(root->left);
    return 1 + min(min_depth_recursively(root->left), min_depth_recursively(root->right));
}

int min_depth_DFS(TreeNode* root) {
    if (!root) return 0;
    stack<TreeNode*> node_stack;
    stack<int> depth_stack;
    node_stack.push(root);
    depth_stack.push(1);
    int min_depth = INT_MAX;
    while (!node_stack.empty()) {
        TreeNode* current = node_stack.top();
        int current_depth = depth_stack.top();
        node_stack.pop();
        depth_stack.pop();
        if (!current->left && !current->right) {
            min_depth = min(min_depth, current_depth);
        }
        if (current->right) {
            node_stack.push(current->right);
            depth_stack.push(current_depth + 1);
        }
        if (current->left) {
            node_stack.push(current->left);
            depth_stack.push(current_depth + 1);
        }
    }
    return min_depth;
}