leetcode：是否是平衡二叉树

最新推荐文章于 2024-07-28 21:09:15 发布

pynash123

最新推荐文章于 2024-07-28 21:09:15 发布

阅读量105

点赞数

分类专栏： leetcode 算法 c++

本文链接：https://blog.csdn.net/pynash123/article/details/95938898

版权

算法同时被 3 个专栏收录

94 篇文章 0 订阅

订阅专栏

c++

63 篇文章 0 订阅

订阅专栏

leetcode

50 篇文章 0 订阅

订阅专栏

题目：
输入一棵二叉树，判断该二叉树是否是平衡二叉树。
思路1：
首先算出每个子树的深度并保存，然后判断
代码1：

class Solution {
public:
    bool IsBalanced_Solution(TreeNode* pRoot) 
    {
        if(NULL == pRoot)
        {
            return true;
        }
        TreeDepth(pRoot);
        return IsBalanced(pRoot);
    }
    
    bool IsBalanced(TreeNode* pRoot) 
    {
        if(NULL == pRoot)
        {
            return true;
        }
        
        int left  = NULL != pRoot->left ? m_map[pRoot->left] : 0;
        int right = NULL != pRoot->right ? m_map[pRoot->right] : 0;
        if(abs(left - right) > 1)
        {
            return false;
        }
        
        return IsBalanced(pRoot->left) && IsBalanced(pRoot->right);
    }
    
    int TreeDepth(TreeNode* pRoot)
    {
        if(NULL == pRoot)
        {
            return 0;
        }
        int left = NULL != pRoot->left ? TreeDepth(pRoot->left) : 0;
        if(NULL != pRoot->left)
        {
            m_map[pRoot->left] = left;
        }
        int right = NULL != pRoot->right ? TreeDepth(pRoot->right) : 0;
        if(NULL != pRoot->right)
        {
            m_map[pRoot->right] = right;
        }
        return max(left, right) + 1;
    }
    
    map<TreeNode*, int> m_map;
};

思路2：
计算每个子树的深度和判断同时进行
代码2：

struct tRes
{
    bool bRes;
    int iDepth;
    tRes(bool res, int depth)
    {
        bRes = res;
        iDepth = depth;
    }
};

class Solution {
public:
    bool IsBalanced_Solution(TreeNode* pRoot) 
    {
        if(NULL == pRoot)
        {
            return true;
        }
        return TreeDepth(pRoot).bRes;
    }
    
    tRes TreeDepth(TreeNode* pRoot)
    {
        if(NULL == pRoot)
        {
            return tRes(true, 0);
        }
        tRes leftRes = NULL != pRoot->left ? TreeDepth(pRoot->left) : tRes(true, 0);
        tRes rightRes = NULL != pRoot->right ? TreeDepth(pRoot->right) : tRes(true, 0);
        if(false == leftRes.bRes || false == rightRes.bRes)
        {
            return tRes(false, 0);
        }
        return tRes(abs(leftRes.iDepth - rightRes.iDepth) <= 1, max(leftRes.iDepth, rightRes.iDepth) + 1);
    }
};