【算法训练 day19 二叉树的最大深度、二叉树的最小深度、完全二叉树的节点个数】

---

一、二叉树的最大深度-LeetCode 104

Leecode链接: leetcode 104
文章链接: 代码随想录
视频链接: B站

二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

示例：

输入：root = [3,9,20,null,null,15,7]
输出：3

思路

深度计算层序遍历最容易写出来，每有1次外层循环就代表有1的深度，使用计数器计数即可。递归的思路不同，他不是一层一层计数，而是将问题拆分成先计算两个子树的深度，然后取最大值再加上自己的深度。

实现代码

1.迭代

//cpp
class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*>que;
        if(root!=NULL){
            que.push(root);
        }

        int depth=0;

        while(!que.empty()){
            int size_que = que.size();
            depth++;//进如while循环表明就有一层,直接加1

            for(int i = 0;i<size_que;i++){
                TreeNode* t = que.front();
                que.pop();
                if(t->left){
                    que.push(t->left);
                }
                if(t->right){
                    que.push(t->right);
                }
            }
        }

        return depth;
    }
};

2.递归

//cpp
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == nullptr) return 0;
        int leftdepth = maxDepth(root->left);
        int rightdepth = maxDepth(root->right);
        int dp = 1 + max(leftdepth,rightdepth);
        return dp;
    }
};

个人问题

递归法一开始没有反应过来，看了思路才是写出来。

总结

整体比较简单。

---

二、二叉树的最小深度-LeetCode 111

Leecode链接: LeetCode 111
文章链接: 代码随想录
视频链接: B站

给定一个二叉树，找出其最小深度。

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明：叶子节点是指没有子节点的节点。

示例：

输入：root = [3,9,20,null,null,15,7]
输出：2

思路

迭代思路：层序遍历，使用计数器计录深度，当节点不为叶子节点时继续遍历，当遇到第一个叶子节点时，立马退出循环，并返回计数器的值。递归思路：也是拆开来计算，但需要加if来判断是不是叶子节点，根据判断结果做不同操作。

实现代码

1.迭代

//cpp
class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*>que;
        if(root!=NULL){
            que.push(root);
        }
        int min_de = 0;

        while(!que.empty()){
            int size = que.size();
            min_de++;
            for(int i = 0;i<size;i++){
                TreeNode* t = que.front();
                que.pop();
                if(t->left){
                    que.push(t->left);
                }
                if(t->right){
                    que.push(t->right);
                }
                if(!t->left&&!t->right){
                    return min_de;
                }
            }
        }
        return min_de;
    }
};

2.递归

//cpp
class Solution {
public:
    int getDepth(TreeNode* node) {
        if (node == NULL) return 0;
        int leftDepth = getDepth(node->left);           // 左
        int rightDepth = getDepth(node->right);         // 右
                                                        // 中
        // 当一个左子树为空，右不为空，这时并不是最低点
        if (node->left == NULL && node->right != NULL) { 
            return 1 + rightDepth;
        }   
        // 当一个右子树为空，左不为空，这时并不是最低点
        if (node->left != NULL && node->right == NULL) { 
            return 1 + leftDepth;
        }
        int result = 1 + min(leftDepth, rightDepth);
        return result;
    }

    int minDepth(TreeNode* root) {
        return getDepth(root);
    }
};

个人问题

没有实现出递归代码，在递归体中直接取了最小值，导致最后结果为1。

总结

题目需要注意的是，需要在递归体中来判断是不是叶子节点，如果不是叶子节点，那就取该节点两个子树中深度最小值的那棵，如果该节点为叶子节点，那就表明访问到树的底部，正常返回0即可，如果该节点不是叶子节点且左右子树中有一个为空，那就返回不为空的那一侧的值，这样就保证考虑到所有情况。

---

三.完全二叉树的节点个数-LeeCode 222

Leecode链接: LeetCode 222
文章链接: 代码随想录
视频链接: B站

给你一棵 完全二叉树 的根节点 root ，求出该树的节点个数。

完全二叉树 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。

示例：

输入：root = [1,2,3,4,5,6]
输出：6

思路

递归思路：计算左右子树的节点数，然后集中计算，显然用后续遍历比较便于理解；迭代思路：使用层序遍历，每插入到队列一次，代表有一个节点，计数加一。

实现代码

1.迭代

//cpp
class Solution {
public:
    int countNodes(TreeNode* root) {
        queue<TreeNode*>que;
        if(root == nullptr) return 0;

        que.push(root);
        int sum = 1;
        while(!que.empty()){
            int size = que.size();
            while(size--){
                TreeNode* t = que.front();
                que.pop();
                if(t->left) {
                    que.push(t->left);
                    sum++;
                }
                if(t->right) {
                    que.push(t->right);
                    sum++;
                }
            }
        }
        return sum;
    }
};

2.递归

//cpp
class Solution {
public:
    int countNodes(TreeNode* root) {
        if(root == nullptr){
            return 0;
        }
        int leftsum = countNodes(root->left);
        int rightsum = countNodes(root->right);
        int sum = 1 + leftsum + rightsum;
        return sum;
    }
};

个人问题

无。

总结

简单题，加深对二叉树的遍历书写印象,以上三题使用层序遍历来做的话，都比较简单直接明了，递归绕了点。