LeetCode110. 平衡二叉树(day0013_2)

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

示例 1：

 输入：root = [3,9,20,null,null,15,7]
 输出：true

示例 2：

 输入：root = [1,2,2,3,3,null,null,4,4]
 输出：false

示例 3：

 输入：root = []
 输出：true

提示：

• 树中的节点数在范围 [0, 5000] 内

• -104 <= Node.val <= 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 result;
    void getDepth(TreeNode* node,int depth){
        result=depth>result?depth:result;//中
        if(node->left==nullptr&&node->right==nullptr)return;
        if(node->left){
            depth++;
            getDepth(node->left,depth);//左
            depth--;//回溯
        }
        if(node->right){
            depth++;
            getDepth(node->right,depth);//右
            depth--;//回溯
        }
        return ;
    }
    int maxDepth(TreeNode* root) {
        result=0;
        if(root==0)return result;
        getDepth(root,1);
        return result;
    }
};

简化版：

/**
 * 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 result;
    void getDepth(TreeNode* node,int depth){
        result=depth>result?depth:result;
        if(node->left==nullptr&&node->right==nullptr)return ;
        if(node->left){
            getDepth(node->left,depth+1);
        }
        if(node->right){
            getDepth(node->right,depth+1);
        }
        return;
    }
    int maxDepth(TreeNode* root) {
        result=0;
        if(root==nullptr)return result;
        getDepth(root,1);
        return result;
    }
};

*代码递归中运用了回溯过程

正文：

递归代码：

/**
 * 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 getDepth(TreeNode* node){
        if(node==NULL)return 0;
        int leftDepth=getDepth(node->left);
        if(leftDepth==-1)return -1;
        int rightDepth=getDepth(node->right);
        if(rightDepth==-1)return -1;
        return abs(leftDepth-rightDepth)>1?-1:1+max(leftDepth,rightDepth);
    }
    bool isBalanced(TreeNode* root) {
        return getDepth(root)==-1?false:true;
    }
};

*求高度，用迭代算法，回溯过程不能更好的利用，有浪费，不建议使用。