算法24： 平衡二叉树

一、需求

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

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

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 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

示例 4：

输入：root = [1,2]
输出：true

提示：

• 树中的节点数在范围 [0, 5000] 内
• -104 <= Node.val <= 104

二、思路分析图【递归】

最后这一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 ，所以这个是平衡二叉树

三、代码

公共代码

TreeNode（节点类）

package com.bessky.pss.wzw.SuanFa;

import java.util.ArrayList;
import java.util.List;

/**
 * 树节点类
 *
 * @author 王子威
 * @date 2022/7/27
 */
public class TreeNode
{
    int val;

    TreeNode left;

    TreeNode right;

    TreeNode()
    {
    }

    TreeNode(int val)
    {
        this.val = val;
    }

    TreeNode(int val, TreeNode left, TreeNode right)
    {
        this.val = val;
        this.left = left;
        this.right = right;
    }

    /**
     * 遍历显示
     *
     * @return
     */
    public String display()
    {
        // 创建存储先序遍历后的结果
        List<Integer> results = new ArrayList<>();

        // 调用:递归方法
        this.inorder(this, results);

        return results.toString();
    }

    /**
     * 递归方法体
     *
     * @param root
     * @param results
     */
    public void inorder(TreeNode root, List<Integer> results)
    {
        if (root == null)
        {

            return;
        }

        // 调用:当最左时就存储 || 或左没有时存储
        results.add(root.val);
        // 调用:递归方法（先把最左边的拿到）
        inorder(root.left, results);

        // 调用:递归方法（左没有时就递归右边）
        inorder(root.right, results);
    }
}

（一）递归方案

①数据初始化

/**
 * 入口
 *      110. 平衡二叉树
 * 输入：
 *      TreeNode root = [3,9,20,null,null,15,7]
 * 输出：
 *      result1 = 是平衡二叉树
 * 解释：
 *      1.递归
 */
@Test
public void suanfa24()
{
    TreeNode root = new TreeNode(3, new TreeNode(9), new TreeNode(20, new TreeNode(15), new TreeNode(7)));

    System.out.println(this.isBalanced(root) ? "是平衡二叉树" : "不是平衡二叉树");
}

②测试方法

/**
 * 递归方案：判断是否平衡树方法
 *
 * @param root
 * @return
 */
private boolean isBalanced(TreeNode root)
{
    // 如果root == null 或者 （递归左子树层 - 递归右子树层）的绝对值数量小于等于1 与 递归左子树 与 递归右子树
    // 后面的再次递归主要是预防[1,2]这种树
    return root == null || Math.abs(this.bstRecursion(root.left) - this
            .bstRecursion(root.right)) <= 1 && isBalanced(root.left) && isBalanced(root.right);
}

③递归方法

/**
 * 累加计算二叉树的层次
 *
 * @param root
 * @return
 */
private int bstRecursion(TreeNode root)
{
    // 递归比较，获取最深的子层（累加计算二叉树的层次）
    return  root == null ? 0 : Math.max(this.bstRecursion(root.left), this.bstRecursion(root.right)) + 1;
}

④结果图

（二）递归方案

这个效率最高，是优化后的算法，参考了网络，没做思路分析，我觉得应该是我一直在测试的方案最终版

①数据初始化

/**
 * 入口
 *      110. 平衡二叉树
 * 输入：
 *      TreeNode root = [3,9,20,null,null,15,7]
 * 输出：
 *      result1 = 是平衡二叉树
 * 解释：
 *      1.递归
 */
@Test
public void suanfa24()
{
    TreeNode root = new TreeNode(3, new TreeNode(9), new TreeNode(20, new TreeNode(15), new TreeNode(7)));

    System.out.println(this.isBalanced(root) ? "是平衡二叉树" : "不是平衡二叉树");
}

②测试方法

/**
 * 递归方案：判断是否平衡树方法
 *
 * @param root
 * @return
 */
private boolean isBalanced(TreeNode root)
{
    return bstRecursion(root) != -1;
}

③递归方法

private int bstRecursion(TreeNode root)
{
    if(root == null)
       {
           return 0;
       }
       int right = bstRecursion(root.right);
       int left = bstRecursion(root.left);
       if(Math.abs(right - left) > 1 || left == -1 || right == -1)
       {
           return -1;
       }
       return Math.max(right, left) + 1;
}

④结果图

作者：王子威

四、总结

• 学习了平衡二叉树的校验
• 有丝丝进步，递归的逻辑有些清晰了，但是自己写还是有难度的，感觉思维感和大局观都不够，想象不到内容
• 一个二叉树每个节点的左右子树的高度差的绝对值不超过1（树中所有的子树都是平衡树，这个结果才会是平衡树）
• 算法兴趣+1 总:24
• 加强了对算法的分析能力