代码随想录DAY16：二叉树

二叉树

104. 二叉树的最大深度

104.二叉树的最大深度

题目描述

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

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

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

思路

递归法
迭代法

代码

递归法

/**
 * 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 == NULL)
        {
            return 0;
        }
        int leftMax = maxDepth(root->left);
        int rightMax = maxDepth(root->right);
        int res = max(leftMax,rightMax) + 1;
        return res;
    }
};

迭代法（待补充）

111. 二叉树的最小深度

111.二叉树的最小深度

题目描述

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

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

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

思路

递归法

迭代法：
每层遍历时，若节点的左右子节点都为NULL，则到达叶子节点，return当前深度。

代码

/**
 * 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;
        if (root != NULL)   que.push(root);
        int depth = 0;

        while (!que.empty())
        {
            int size = que.size();
            depth ++;
            
            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 depth;
            }
        }
        return depth;
    }
};

完全二叉树的节点个数

题目描述

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

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

思路

1、适用于普通二叉树的方法
遍历树中节点，可用递归法和迭代法

2、利用完全二叉树性质
分两种情况：
（1）满二叉树：用 2 ^ 树深度 - 1，根节点深度为 1
（2）最后一层叶子节点没有填满：递归左右孩子，直至递归到满二叉树，回到（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) {
        queue<TreeNode*> que;
        if (root != NULL)   que.push(root);
        int res = 0;

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

利用完全二叉树性质处理

//利用完全二叉树性质处理
class Solution {
public:
    int countNodes(TreeNode* root) {
        if (root == NULL)   return 0;
        TreeNode* left =root->left;
        TreeNode* right = root->right;
        int leftHeight = 0;
        int rightHeight = 0;
        while (left)
        {
            left = left->left;
            leftHeight++;
        }
        while (right)
        {
            right = right->right;
            rightHeight++;
        }
        if (leftHeight == rightHeight)
        {
            return (2 << leftHeight) - 1;
        }
        int leftNum = countNodes(root->left);
        int rightNum = countNodes(root->right);
        int sum = leftNum + rightNum + 1;
        return sum;
    }
};