LeetCode 110 Balanced Binary Tree

最新推荐文章于 2024-10-17 18:02:45 发布

原创最新推荐文章于 2024-10-17 18:02:45 发布 · 606 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

【考研机试准备与OJ总结】专栏收录该内容

63 篇文章

订阅专栏

本文详细介绍了使用递归和非递归两种方式来判断二叉树的平衡性，并通过深度优先搜索算法实现了非递归版本。

题目

题解

非递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int depth(TreeNode* root){
        if(root == NULL)
            return 0;
        int left = depth(root->left);
        int right = depth(root->right);
        return left > right ? left + 1 : right + 1;
    }
    bool isBalanced(TreeNode* root) {
        if(root == NULL)
            return true;
        vector<TreeNode *> vec;
        vec.push_back(root);
        while(!vec.empty()){
            vector<TreeNode*> temp;
            for(int i=0;i<vec.size();i++){
                int left = depth(vec[i]->left);
                int right = depth(vec[i]->right);
                if(abs(left - right)>1)
                    return false;
                else{
                    if(vec[i]->left != NULL)
                        temp.push_back(vec[i]->left);
                    if(vec[i]->right != NULL)
                        temp.push_back(vec[i]->right);
                }
            }
            vec = temp;
        }
        return true;
    }
};

递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int depth(TreeNode* root){
        if(root == NULL)
            return 0;
        int left = depth(root->left);
        int right = depth(root->right);
        return left > right ? left + 1 : right + 1;
    }
    bool isBalanced(TreeNode* root) {
        if(root == NULL)
            return true;
        bool left = isBalanced(root->left);
        bool right = isBalanced(root->right);
        if(left && right){
            if(abs(depth(root->left) - depth(root->right)) <=1)
                return true;
        }
        return false;
    }
};