二叉树的最大深度，详解伪代码、Python、C++代码实现过程！

2023-09-28 20:34:37

算法

二叉树是一种常见的数据结构，它由结点和边组成。结点是存储数据的单位，边是连接两个结点的线段。二叉树的最大深度是指从根结点到最深结点的路径上所经过的结点总数。

计算二叉树的最大深度有三种常见算法：递归法、迭代法和广度优先搜索法。

递归法

递归法是一种解决问题的常用方法，它通过不断调用自身来解决问题。在二叉树的最大深度问题中，递归法可以从根结点开始，递归地计算左右子树的最大深度，然后取左右子树的最大深度加1作为当前结点的最大深度。

def max_depth(root):
    if root is None:
        return 0
    else:
        left_depth = max_depth(root.left)
        right_depth = max_depth(root.right)
        return max(left_depth, right_depth) + 1

int max_depth(TreeNode* root) {
    if (root == nullptr) {
        return 0;
    } else {
        int left_depth = max_depth(root->left);
        int right_depth = max_depth(root->right);
        return max(left_depth, right_depth) + 1;
    }
}

迭代法

迭代法是一种非递归的解决方案，它通过不断重复执行某个操作来解决问题。在二叉树的最大深度问题中，迭代法可以利用栈或队列来存储结点，然后依次访问这些结点，并计算每个结点的最大深度。

def max_depth(root):
    if root is None:
        return 0

    stack = [(root, 1)]
    max_depth = 0

    while stack:
        node, depth = stack.pop()
        max_depth = max(max_depth, depth)

        if node.left:
            stack.append((node.left, depth + 1))

        if node.right:
            stack.append((node.right, depth + 1))

    return max_depth

int max_depth(TreeNode* root) {
    if (root == nullptr) {
        return 0;
    }

    stack<pair<TreeNode*, int>> stack;
    int max_depth = 0;

    stack.push(make_pair(root, 1));

    while (!stack.empty()) {
        TreeNode* node = stack.top().first;
        int depth = stack.top().second;
        stack.pop();

        max_depth = max(max_depth, depth);

        if (node->left) {
            stack.push(make_pair(node->left, depth + 1));
        }

        if (node->right) {
            stack.push(make_pair(node->right, depth + 1));
        }
    }

    return max_depth;
}

广度优先搜索法

广度优先搜索法是一种树的遍历算法，它从根结点开始，逐层遍历二叉树，直到所有结点都被访问过。在二叉树的最大深度问题中，广度优先搜索法可以利用队列来存储结点，然后依次访问这些结点，并计算每个结点的最大深度。

def max_depth(root):
    if root is None:
        return 0

    queue = [root]
    max_depth = 0

    while queue:
        level_size = len(queue)
        max_depth += 1

        for _ in range(level_size):
            node = queue.pop(0)

            if node.left:
                queue.append(node.left)

            if node.right:
                queue.append(node.right)

    return max_depth

int max_depth(TreeNode* root) {
    if (root == nullptr) {
        return 0;
    }

    queue<TreeNode*> queue;
    int max_depth = 0;

    queue.push(root);

    while (!queue.empty()) {
        int level_size = queue.size();
        max_depth += 1;

        for (int i = 0; i < level_size; i++) {
            TreeNode* node = queue.front();
            queue.pop();

            if (node->left) {
                queue.push(node->left);
            }

            if (node->right) {
                queue.push(node->right);
            }
        }
    }

    return max_depth;
}