二叉树03（leetcode104,559,111,222）

最新推荐文章于 2024-10-05 19:23:25 发布

闪ba

最新推荐文章于 2024-10-05 19:23:25 发布

阅读量618

点赞数 19

分类专栏：力扣题解文章标签：算法数据结构

本文链接：https://blog.csdn.net/weixin_62372284/article/details/138036128

版权

力扣题解专栏收录该内容

46 篇文章 0 订阅

订阅专栏

文章详细介绍了如何使用递归后序遍历算法计算二叉树和N叉树的最大深度，以及完全二叉树的节点个数，包括相应的代码实现和示例。

摘要由CSDN通过智能技术生成

参考资料：

https://programmercarl.com/0104.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%A4%A7%E6%B7%B1%E5%BA%A6.html

104. 二叉树的最大深度

题目描述：

给定一个二叉树 root ，返回其最大深度。

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

示例 1：

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

思路分析：

这题有多种解法，层序遍历，递归（后序，前序）均可。

此处主要讲递归的后序遍历写法

后序遍历求结点的高度，题目要求的最大深度就是根节点的高度。

收集左右子节点的高度向中间结点返回。

代码实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */

// class Solution {
// public:
//     int maxDepth(TreeNode* root) {
//         //迭代，层序遍历
//         if(root==nullptr) return 0;
//         queue<TreeNode*> q;
//         q.push(root);
//         int ans=0;
//         while(!q.empty()){
//             int size=q.size();
//             while(size>0){//将该层所有节点遍历
//                 TreeNode* node=q.front();
//                 q.pop();
//                 if(node->left) q.push(node->left);
//                 if(node->right) q.push(node->right);
//                 size--;
//             }
//             ans++;
//         }
//         return ans;
//     }
// };


// 递归
// 后序
class Solution {
public:
    //后续遍历求根结点高度
    //（最大深度就是根的高度）
    int getDep(TreeNode* node){
        if(node==nullptr) return 0;

        int leftDept=getDep(node->left);
        int rightDept=getDep(node->right);//左右
        return 1+max(leftDept,rightDept);//中
    }

    int maxDepth(TreeNode* root) {
        return getDep(root);
    }
};


// //递归
// //前序
// class Solution {
// public:
//     //前序遍历求最大深度
//     int result=0;
//     void getDep(TreeNode* node,int dept){
//         result=max(result,dept);
//         if(node==nullptr) return;

//         if(node->left){
//             dept++;
//             getDep(node->left,dept);
//             dept--;//!!回溯
//         }
//         if(node->right){
//             dept++;
//             getDep(node->right,dept);
//             dept--;//回溯
//         }
//         return;
//     }

//     int maxDepth(TreeNode* root) {
//         result=0;
//         if(root==nullptr) return result;
//         getDep(root,1);
//         return result;
//     }
// };

559. N 叉树的最大深度

题目描述：

给定一个 N 叉树，找到其最大深度。

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

N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。

示例 1：

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

思路分析：

思路与104完全相同，只是从二叉变为n叉：

max( leftDept, rightDept ) ——> max（dept,maxDept(children[i]）

代码实现：

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/
//思路同 104
class Solution {
public:
    //递归，后序——>根节点高度——>深度
    int maxDepth(Node* root) {
        if(root==nullptr) return 0;
        int depth=0;
        for(int i=0;i<root->children.size();i++){
            depth=max(depth,maxDepth(root->children[i]));
        }
        return depth+1;
    }
};

111. 二叉树的最小深度

题目描述：

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

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

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

示例 1：

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

思路分析：

单层递归逻辑中：

如果任一孩子为空，另一不为空，则返回不为空那边。

注意：不能直接返回min(leftD,rightD)，否则会未到叶子结点就返回了。

代码实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */

// class Solution {
// public:
//     //迭代法
//     int minDepth(TreeNode* root) {
//         queue<TreeNode*> que;
//         int minDepth=0;
//         if(root!=nullptr) que.push(root);
//         while(!que.empty()){
//             minDepth++;
//             int size=que.size();
//             for(int i=0;i<size;i++){
//                 TreeNode* node=que.front();
//                 que.pop();
//                 if(node->left) que.push(node->left);
//                 if(node->right) que.push(node->right);
//                 if(!node->left && !node->right){
//                     return minDepth;
//                 }
//             }
//         }
//         return minDepth;

//     }
// };

class Solution {
public:
//递归，后序遍历
    int minDepth(TreeNode* root) {
        if(root==nullptr) return 0;
        int leftD=minDepth(root->left);
        int rightD=minDepth(root->right);
        
        if(leftD==0 && rightD!=0){
            return 1+rightD;
        }
        if(leftD!=0 && rightD==0){
            return 1+leftD;
        }
        return 1+min(leftD,rightD);
    }
};

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

题目描述：

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

示例 1：

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

思路分析：

关键：利用完全二叉树的特性，降低时间复杂度。

递归结束条件：

若遇到以该结点为根结点的子树是完全二叉树，则可返回该完全二叉树的节点总数。（中间部分节点不用再遍历，降低了时间复杂度）。

补充小知识：2^n == 2<<(n-1)

代码实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    //利用完全二叉树的特点简化减少时间复杂度
    //递归，后序遍历
    int countNodes(TreeNode* root) {
        //终止条件
        if(root==nullptr) return 0;
        TreeNode* left=root->left;
        TreeNode* right=root->right;
        int leftD=0,rightD=0;//从0开始便于用公式计算完全二叉树节点数
        while(left){
            left=left->left;
            leftD++;
        }
        while(right){
            right=right->right;
            rightD++;
        }
        if(leftD==rightD)
            return (2<<leftD)-1;// 2^2 == 2<<1

        //单层递归逻辑
        int leftCount=countNodes(root->left);//左
        int rightCount=countNodes(root->right);//右
        return leftCount+rightCount+1;//中

    }
};