【代码随想录】【算法训练营】【第16天】 [104]二叉树的最大深度 [111]二叉树的最小深度 [222]完全二叉树的节点个数

最新推荐文章于 2024-09-22 20:09:34 发布

may-daydayup

最新推荐文章于 2024-09-22 20:09:34 发布

阅读量290

点赞数 5

分类专栏： Algorithms 文章标签：算法

本文链接：https://blog.csdn.net/weixin_54954007/article/details/139138048

版权

Algorithms 专栏收录该内容

63 篇文章 2 订阅

订阅专栏

前言

思路及算法思维，指路代码随想录。
题目来自 LeetCode。

day 16，周四，再坚持一下吧~

题目详情

[104] 二叉树的最大深度

题目描述

104 二叉树的最大深度

解题思路

前提：二叉树的最大深度，等价于二叉树的层数，等价于求最底层二叉树叶子结点的高度。
思路：求二叉树深度：前序遍历；求二叉树高度：后序遍历；求二叉树层数：层级遍历。
重点：二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数或者节点数（取决于深度从0开始还是从1开始）；二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数或者节点数（取决于高度从0开始还是从1开始）。

代码实现

C语言

层级遍历队列

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
int maxDepth(struct TreeNode* root) {
    int ans = 0;
    // 判断树非空
    if (root == NULL)
    {
        return ans;
    }
    // 层级遍历， 队列
    struct TreeNode *queue[10000];
    int idx = 0;
    queue[idx++] = root;
    int start = 0;
    while (start < idx)
    {
        int levelCnt = idx - start;
        for (int i = 0; i < levelCnt; i++)
        {
            struct TreeNode *cur = queue[start++];
            if (cur->left)
            {
                queue[idx++] = cur->left;
            }
            if (cur->right)
            {
                queue[idx++] = cur->right;
            }
        }
        ans++;
    }
    return ans;
}

后序遍历求root的高度，递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int max(int a, int b)
{
    return (a > b) ? a : b;
}

int hight(struct TreeNode* root)
{
    // 后序遍历求高度，最大深度即为root的高度
    if (root == NULL)
    {
        return 0;
    }
    int leftHight = hight(root->left);
    int rightHight = hight(root->right);
    return 1 + max(leftHight, rightHight);
}

int maxDepth(struct TreeNode* root) {
    // 后序遍历求高度，最大深度即为root的高度，递归
    return hight(root);
}

前序遍历求root深度，递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int max(int a, int b)
{
    return (a > b) ? a : b;
}

void depthFun(struct TreeNode* root, int depth, int *result)
{
    // 前序遍历求深度, 注意回溯的过程
    if (root == NULL)
    {
        return ;
    }
    *result = max(*result, depth);
    depthFun(root->left, depth + 1, result);
    depthFun(root->right, depth + 1, result);
    return ;
}

int maxDepth(struct TreeNode* root) {
    // 后序遍历求高度，最大深度即为root的高度，递归
    int result = 0;
    int depth = 0;
    depthFun(root, depth + 1, &result);
    return result;
}

[111] 二叉树的最小深度

题目描述

111 二叉树的最小深度

解题思路

前提：二叉树的最小深度，等价于二叉树最高层叶子结点的层数，等价于求二叉树最高层叶子结点的高度。
思路：求二叉树深度：前序遍历；求二叉树高度：后序遍历；求二叉树层数：层级遍历。
重点：注意叶子结点的含义: (node->left == NULL) && (node->right == NULL)。

代码实现

C语言

层序遍历，队列

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
int minDepth(struct TreeNode* root) {
    int ans = 0;
    // 判断空树
    if (root == NULL)
    {
        return ans;
    }
    // 层序遍历，队列
    struct TreeNode *queue[100000];
    int idx = 0;
    queue[idx++] = root;
    int start = 0;
    while (start < idx)
    {
        int levelCnt = idx - start;
        ans++;
        for (int i = 0; i < levelCnt; i++)
        {
            struct TreeNode *cur = queue[start++];
            // 判断是否为叶子结点
            if ((cur->left == NULL) && (cur->right == NULL))
            {
                // 找到第一个叶子结点，直接退出
                return ans;
            }
            if (cur->left)
            {
                queue[idx++] = cur->left;
            }
            if (cur->right)
            {
                queue[idx++] = cur->right;
            }
        }
    }
    return ans;
}

前序遍历深度，递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int minFun(int a, int b)
{
    return (a < b) ? a : b;
}

void depthFun(struct TreeNode* root, int depth, int *result)
{
    if (NULL == root)
    {
        return ;
    }
    // 寻找叶子结点
    if ((root->left == NULL) && (root->right == NULL))
    {
        *result = minFun(*result, depth);
        return ;
    }
    depthFun(root->left, depth + 1, result);
    depthFun(root->right, depth + 1, result);
}

int minDepth(struct TreeNode* root) {
    // 判断空树
    if (root == NULL)
    {
        return 0;
    }
    int ans = INT_MAX;
    // 前序遍历，递归
    depthFun(root, 1, &ans);
    
    return ans;
}

[222] 完全二叉树的节点个数

题目描述

222 完全二叉树的节点个数

解题思路

前提：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点。
思路：普通二叉树遍历；利用完全二叉树特性，拆解为n个满二叉树，利用 2^树深度 - 1 来计算。
重点：完全二叉树的特性。

代码实现

C语言

普通二叉树先序遍历递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

void travesal(struct TreeNode *root, int *ans)
{
    if (root == NULL)
    {
        return ;
    }
    //先序遍历
    (*ans)++;
    travesal(root->left, ans);
    travesal(root->right, ans);
}

int countNodes(struct TreeNode* root) {
    int ans = 0;
    travesal(root, &ans);
    return ans;
}

普通二叉树结点数量递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int countNodeNum(struct TreeNode *root)
{
    if (root == NULL)
    {
        return 0;
    }
    int leftNum = countNodeNum(root->left);
    int rightNum = countNodeNum(root->right);
    return (leftNum + rightNum + 1);
}

int countNodes(struct TreeNode* root) {
    int ans = countNodeNum(root);
    return ans;
}

完全二叉树分解成满二叉树，利用满二叉树结点数为2^n -1。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int countNodeNum(struct TreeNode *root)
{
    if (root == NULL)
    {
        return 0;
    }
    int leftDepth = 0;
    int rightDepth = 0;
    struct TreeNode *left = root->left;
    struct TreeNode *right = root->right;
    // 求左侧叶子结点的深度
    while (left)
    {
        leftDepth++;
        left = left->left;
    }
    // 求右侧叶子结点的深度
    while (right)
    {
        rightDepth++;
        right = right->right;
    }
    // 判断是否为满二叉树, 两边深度相同
    // 注意：两侧深度相同的二叉树不是满二叉树，但两侧深度相同的完全二叉树，一定是满二叉树。
    if (leftDepth == rightDepth)
    {
        return (2 << leftDepth) - 1;
    }
    int leftNum = countNodeNum(root->left);
    int rightNum = countNodeNum(root->right);
    return (leftNum + rightNum + 1);
}

int countNodes(struct TreeNode* root) {
    int ans = countNodeNum(root);
    return ans;
}