【LeetCode】【回溯法】剑指 Offer 55 - II. 平衡二叉树思路解析和代码

剑指 Offer 55 - II. 平衡二叉树

题目链接

个人思路

思路

几个思考的问题：

• 如何判断平衡二叉树？
• 如何记录深度？
• 如何记录每个节点的深度？

深度：在算法编程中定义为从当前节点到叶子节点的最大路径长度

• 如果一棵树只有一个结点，其深度为1
• 如果根节点只有左子树没有右子树，深度为左子树深度
• 如果根节点只有右子树没有左子树，深度为右子树深度
• 如果根节点既有左子树又有右子树，深度为二者最大值+1

int getDepth(TreeNode* root){
        if(root == NULL){//递归边界
            return 0;
        }
        int hleft = getDepth(root->left);
        int hright = getDepth(root->right);
        return max(hleft, hright) + 1;
    }

个人错误思路

• 通过树的遍历（个人当时采用前序遍历），遍历树的所有节点，并计算每个节点的对应深度
• 将深度数值存放在一个一维数组中，通过满二叉树中根节点与左右子树的位置关系存放

正确思路-重复遍历节点

• 对根节点计算左子树深度和右子树深度
• 比较两个子树深度之差是否满足平衡二叉树条件
• 继续遍历其他子树节点
• 会出现计算根节点的左右子树深度和计算其左孩子的左右子树深度重复

正确思路-后序遍历节点避免重复

自底向上，后序遍历节点
后序遍历如何体现?

• 先遍历左右子节点，计算并记录左右子节点的深度
• 左右子节点深度做差，判断是否平衡
• 当前的深度即为左右子节点深度的最大值+1

注意

• 对根为空的判断

个人思路代码

错误代码

无法开辟能存放所有节点深度数组

/**
 * 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 tree[1000005];
    int len = 0;
    void preOrder(TreeNode* root, int index){
        if(root == NULL){
            return;
        }
        tree[index] = dfs(root);
        len = index;
        preOrder(root->left, 2 * index);
        preOrder(root->right, 2 * index + 1);
    }
    int dfs(TreeNode* root){
        if(root == NULL){//递归边界
            return 0;
        }
        int hleft = dfs(root->left);
        int hright = dfs(root->right);
        return max(hleft, hright) + 1;
    }

    bool isBalanced(TreeNode* root) {
        preOrder(root, 1);
        bool flag = true;
        for(int i = 1; i <= len; ++i){
            if(abs(tree[2 * i] - tree[2 * i + 1]) > 1){
                flag = false;
                break;
            }
        }
        return flag;
    }
};

会重复遍历节点的代码

class Solution {
public:
    int dfs(TreeNode* root){
        if(root == NULL){//递归边界
            return 0;
        }
        int hleft = dfs(root->left);
        int hright = dfs(root->right);
        return max(hleft, hright) + 1;
    }

    bool isBalanced(TreeNode* root) {
        if(root == NULL){
            return true;
        }
        int hleft = dfs(root->left);
        int hright = dfs(root->right);
        int diff = abs(hleft - hright);
        if(diff > 1){
            return false;
        }
        return isBalanced(root->left) && isBalanced(root->right);
    }
};				

后序遍历

class Solution {
public:
    bool flag = true;
    int dfs(TreeNode* root){
        if(root == NULL || flag == false){
            return 0;
        }
        int hleft = dfs(root->left);
        int hright = dfs(root->right);
        int diff = abs(hleft - hright);
        if(diff > 1){
            flag = false;
        }
        return max(hleft, hright) + 1;
    }
    bool isBalanced(TreeNode* root) {
        dfs(root);
        return flag;
    }
};

class Solution {
public:
    bool dfs(TreeNode* root, int& depth){
        if(root == NULL){
            depth = 0;
            return true;
        }
        int hleft, hright;
        if(dfs(root->left, hleft) && dfs(root->right, hright)){
            int diff = abs(hleft - hright);
            if(diff <= 1){
                depth = max(hleft, hright) + 1;
                return true;
            }
        }
        return false;
    }
    bool isBalanced(TreeNode* root) {
        int depth = 0;
        return dfs(root, depth);
    }
};