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

本文链接：https://blog.csdn.net/weixin_42938283/article/details/129298483

104.二叉树的最大深度

类型： #二叉树
难度： #简单
题目：给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
思路：使用前序遍历求深度。
备注：

二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）
二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数后者节点数（取决于高度从0开始还是从1开始）
根节点的高度就是二叉树的最大深度
递归三部曲：

参数传节点，返回值为高度 int
节点为空时结束递归
单层逻辑左右中，左右 getDepth，中拿往左或往右的最大深度 + 1

实现：
cpp:

/**
 * 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 getDepth(TreeNode* root){
        if (root == NULL) return 0;
        int lDepth = getDepth(root->left);
        int rDepth = getDepth(root->right);
        int mDepth = 1 + max(lDepth, rDepth);
        return mDepth;
    }
    int maxDepth(TreeNode* root) {
        return getDepth(root);
    }
};

go:

/**
 * definition for a binary tree node.
 * type treenode struct {
 *     val int
 *     left *treenode
 *     right *treenode
 * }
 */
func max (a, b int) int {
    if a > b {
        return a;
    }
    return b;
}
// 递归
func maxdepth(root *treenode) int {
    if root == nil {
        return 0;
    }
    return max(maxdepth(root.left), maxdepth(root.right)) + 1;
}

559.n叉树的最大深度

类型： #二叉树
难度： #简单
题目：给定一个 N 叉树，找到其最大深度。
最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
N 叉树输入按层序遍历序列化表示，每组子节点由空值分隔（请参见示例）。
在这里插入图片描述

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

/*
// 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;
    }
};
*/

class Solution {
public:
    int maxDepth(Node* root) {
        if(root == NULL) return 0;
        int depth = 0; 
        for (int i = 0; i < root->children.size(); i++){
            depth = max(depth, maxDepth(root->children[i]));
        }
        return depth+1;
    }
};

101. 对称二叉树

类型： #二叉树
难度： #简单
题目：给你一个二叉树的根节点 root ，检查它是否轴对称。
思路：比较两棵子树是否对称，所以要同时遍历两棵树
在这里插入图片描述

遍历的顺序只能是后序遍历，因为要通过递归函数的返回值来判断两子树内侧节点和外侧节点是否相等。
所以一棵树是左右中，另一棵是中左右
三部曲：

参数左右节点，返回值 bool
排除掉节点为空的多种情况，剩下的就是左右不为空，比较，不同返回 false
1. 左节点为空，右节点不为空，false
2. 左不为空，右为空，false
3. 左右都空，true
处理左右节点不为空，数值相等的情况
1. 比较外侧是否对称：传左节点左孩子，右节点右孩子
2. 比较内侧是否对称：传左节点右孩子，右节点左孩子
3. 都对称 true，一侧不对称 false
  实现：

/**
 * 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:
    bool compare(TreeNode* left, TreeNode* right){
        if(left == NULL && right != NULL) return false;
        else if(left != NULL && right == NULL) return false;
        else if(left == NULL && right == NULL) return true;
        else if(left->val != right->val) return false;

        bool outSide = compare(left->left, right->right);
        bool inSide = compare(left->right, right->left);
        bool isSame = outSide && inSide;
        return isSame;
    }
    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        return compare(root->left, root->right);
    }
};

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func defs(left *TreeNode, right *TreeNode) bool {
    if left == nil && right == nil {
        return true;
    };
    if left == nil || right == nil {
        return false;
    };
    if left.Val != right.Val {
        return false;
    }
    return defs(left.Left, right.Right) && defs(right.Left, left.Right);
}

func isSymmetric(root *TreeNode) bool {
    return defs(root.Left, root.Right);
}

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

类型： #二叉树
难度： #中等
题目：给你一棵完全二叉树的根节点 root ，求出该树的节点个数。完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2h 个节点。
思路：递归返回个数，节点为空时结束递归返回 0，单层递归左右中
实现：

/**
 * 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 countNums(TreeNode* cur){
        if(cur == NULL) return 0;

        int leftNum = countNums(cur->left);
        int rightNum = countNums(cur->right);
        int nums = leftNum + rightNum + 1;
        return nums;
    }

    int countNodes(TreeNode* root) {
        return countNums(root);
    }
};