代码随想录算法训练营第16天 | 第六章 二叉树 part03 ● 104.二叉树的最大深度 559.n叉树的最大深度 ● 111.二叉树的最小深度 ● 222.完全二叉树的节点个数

2023年4月11日 16:06:41

第六章 二叉树part03

今日内容：

● 104.二叉树的最大深度 559.n叉树的最大深度

● 111.二叉树的最小深度

● 222.完全二叉树的节点个数

迭代法，大家可以直接过，二刷有精力的时候 再去掌握迭代法。

---

详细布置

104.二叉树的最大深度 （优先掌握递归）

【链接】（文章，视频，题目）

什么是深度，什么是高度，如何求深度，如何求高度，这里有关系到二叉树的遍历方式。

大家 要先看视频讲解，就知道以上我说的内容了，很多录友刷过这道题，但理解的还不够。

题目链接/文章讲解/视频讲解： 代码随想录

【第一想法与实现（困难）】

• 之前写过的，层序遍历，直接迭代方法，一层加一个深度

【看后想法】

• 层序遍历，直接使用迭代方法，容易理解，相当于层序遍历的模板题

• 递归后序遍历，也比较好理解，左右中

• 递归前序遍历，单独增加一个类内成员变量，存储中间最大深度结果，设计函数稍有不同

【实现困难】

【自写代码】

class Solution {
public:
    // 参数返回值
    int GetDpeth(TreeNode* node) {
        // 结束条件
        if (!node) {
            return 0;
        }
        // 单层递归逻辑：深度=各子树深度最大值+1
        int left = GetDpeth(node->left);
        int right = GetDpeth(node->right);
        return std::max(left, right) + 1;
    }
    int maxDepth(TreeNode* root) {
        // 采用递归的思想，深度=各子树深度最大值+1（本层）。因此是后序遍历，左右中
        return GetDpeth(root);
    }
};

class Solution {
public:
    int max_depth;
    void GetDepth(Node* node, int depth) {
        max_depth = std::max(max_depth, depth);
        if (node->children.empty()) {
            return;
        }
        for (Node* child : node->children) {
            if (child) {
                GetDepth(child, depth + 1);
            }
        }
    }
    int maxDepth(Node* root) {
        // 递归遍历，前序遍历
        max_depth = 0;
        if (!root) {
            return max_depth;;
        }
        GetDepth(root, 1);
        return max_depth;
    }
};

【收获与时长】1h

---

111.二叉树的最小深度 （优先掌握递归）

【链接】（文章，视频，题目）

先看视频讲解，和最大深度 看似差不多，其实 差距还挺大，有坑。

题目链接/文章讲解/视频讲解：代码随想录

【第一想法与实现（困难）】

• 层序遍历，直到叶子结点，迭代方法

【看后想法】

• 后序遍历，最小深度要注意只有一个孩子为空的情况，不能取min，要直接非空的+1

【实现困难】

【自写代码】

class Solution {
public:
    int GetMinDepth(TreeNode* node) {
        // 结束条件
        if (!node) {
            return 0;
        }
        int left_min_depth = GetMinDepth(node->left);  // 左
        int right_min_depth = GetMinDepth(node->right); // 右
        // 中，处理
        if (node->left && node->right) {
            return 1 + std::min(left_min_depth, right_min_depth);
        }
        if (!(node->left) && node->right) {
            return 1 + right_min_depth;
        }
        if (node->left && !(node->right)) {
            return 1 + left_min_depth;
        }
        return 1;
    }
    int minDepth(TreeNode* root) {
        return GetMinDepth(root);
    }
};

【收获与时长】45m

---

222.完全二叉树的节点个数（优先掌握递归）

【链接】（文章，视频，题目）

需要了解，普通二叉树 怎么求，完全二叉树又怎么求

题目链接/文章讲解/视频讲解：代码随想录

【第一想法与实现（困难）】

• 任意一种遍历方法，都可以知道结点个数，直接写的层序遍历

【看后想法】

• 递归方法写起来很简洁，递归思想是由于本身这类问题很多可以用分而治之的方法去解决

• 递归后续遍历写起来很容易，左中右，要先熟练递归三部曲，再简化函数

• 要用上完全二叉树的特性，就可以判断进来的子树，是不是满二叉树，进而快速返回节点数目

【实现困难】

【自写代码】

public:
    int countNodes(TreeNode* root) {
        // 结束条件
        if (!root) {
            return 0;
        }
        // 单层处理逻辑
        return 1 + countNodes(root->left) + countNodes(root->right);
    }
};

class Solution {
public:
    int countNodes(TreeNode* root) {
        // 利用完全二叉树特性，判断满二叉树，求结点数目
        // 结束条件，空，满二叉树
        if (!root) {
            return 0;
        }
        TreeNode* left = root->left;
        TreeNode* right = root->right;
        int left_depth = 0;
        int right_depth = 0;
        while (left) {
            left = left->left;
            ++left_depth;
        }
        while (right) {
            right = right->right;
            ++right_depth;
        }
        if (left_depth == right_depth) { // 是满二叉树
            return (2 << left_depth) - 1;
        }
        // 单层逻辑，后序遍历，左右中
        return 1 + countNodes(root->left) + countNodes(root->right);
    }
};

【收获与时长】35m