文章目录
问题描述
给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：一个二叉树 每个节点 的左右两个子树的高度差的绝对值不超过1。
示例 1:
给定二叉树 [3,9,20,null,null,15,7]
返回 true 。
示例 2:
给定二叉树 [1,2,2,3,3,null,null,4,4]
返回 false 。
思考
咋眼一看这道题目和二叉树：看看这些树的最大深度很像，其实有很大区别。
这里强调一波概念：
二叉树某节点的深度：指从根节点到该节点的最长简单路径边的条数。
二叉树某节点的高度：指从该节点到叶子节点的最长简单路径边的条数。
但leetcode中强调的深度和高度很明显是按照节点来计算的，如图：
关于根节点的深度究竟是1 还是 0，不同的地方有不一样的标准，leetcode的题目中都是以节点为一度，即根节点深度是1。但维基百科上定义用边为一度，即根节点的深度是0，我们暂时以leetcode为准（毕竟要在这上面刷题）。
因为求深度可以从上到下去查 所以需要前序遍历（中左右），而高度只能从下到上去查，所以只能后序遍历（左右中）
有的同学一定疑惑，为什么二叉树：看看这些树的最大深度中求的是二叉树的最大深度，也用的是后序遍历。
「那是因为代码的逻辑其实是求的根节点的高度，而根节点的高度就是这颗树的最大深度，所以才可以使用后序遍历。」
核心：无论是高度还是深度，都按照从下到上去查，用后序遍历（左右中）
【二叉树 2.2】二叉树的最大深度和最小深度
解法一：递归
此时大家应该明白了既然要求比较高度，必然是要后序遍历。
递归三步曲
第一，明确递归函数的参数和返回值
参数的话为传入的节点指针，就没有其他参数需要传递了，返回值要返回传入节点为根节点树的深度。
那么如何标记左右子树是否差值大于1呢。
如果当前传入节点为根节点的二叉树已经不是二叉平衡树了，还返回高度的话就没有意义了。
所以如果已经不是二叉平衡树了，可以返回-1 来标记已经不符合平衡树的规则了。
代码如下：
// -1 表示已经不是平衡二叉树了，否则返回值是以该节点为根节点树的高度
int getDepth(TreeNode* node)
第二，明确终止条件
递归的过程中依然是遇到空节点了为终止，返回0，表示当前节点为根节点的高度为0
代码如下：
if (node == NULL) {
return 0;
}
第三，明确单层递归的逻辑
如何判断当前传入节点为根节点的二叉树是否是平衡二叉树呢，当然是左子树高度和右子树高度相差。
分别求出左右子树的高度，然后如果差值小于等于1，则返回当前二叉树的高度，否则则返回-1，表示已经不是二叉树了。
代码如下：
int leftDepth = depth(node->left); // 左 这里接收了返回值，因为单次递归的中修改的变量不是类变量，不接收返回值就无法更新Solution主方法的变量了
if (leftDepth == -1) return -1;
int rightDepth = depth(node->right); // 右
if (rightDepth == -1) return -1;
int result;
if (abs(leftDepth - rightDepth) > 1) { // 中
result = -1;
} else {
result = 1 + max(leftDepth, rightDepth); // 以当前节点为根节点的最大高度
}
return result;
这里接收了返回值，因为单次递归的中修改的变量不是类变量，不接收返回值就无法更新Solution主方法的变量了
代码精简之后如下：
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);
这里接收了返回值，因为单次递归的中修改的变量不是类变量，不接收返回值就无法更新Solution主方法的变量了
此时递归的函数就已经写出来了，这个递归的函数传入节点指针，返回以该节点为根节点的二叉树的高度，如果不是二叉平衡树，则返回-1。
getDepth整体代码如下：
int getDepth(TreeNode* node) {
if (node == NULL) {
return 0; // 节点为空，高度为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);
}
递归算法
最后本题整体递归代码如下：
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;
// 这里的abs 就是 absolute，就是绝对值
// 为什么这里是1+Math.max
// 1+ 因为没每次遍历了一个节点，高度要加1
// Math.max是因为这里要取出某节点的最大深度
int depth = Math.abs(leftDepth - rightDepth)>1 ? -1: 1+Math.max(leftDepth,rightDepth);
return depth;
}
public boolean isBalanced(TreeNode root) {
return getDepth(root)==-1 ? false: true;
}
}
两个方法不好看，但是此时我们无法合并成成一个方法，因为给定的方法isBalanced，返回值是bool，无法记录depth，如果给定的方法和递归方法仅仅是参数不同，我们可以将这个参数变为类变量，两个方法共享，但是但如果是返回值不同，没办法。
记住三个知识点：
1、这里的abs 就是 absolute，就是绝对值
2、这里的abs 就是 absolute，就是绝对值
3、为什么这里是1+Math.max：1+ 因为没每次遍历了一个节点，高度要加1；Math.max是因为这里要取出某节点的最大深度。
解法二：迭代（后序迭代写成一个获取最大深度，前序迭代写成一个每个节点对最大深度的比较，因为是前序，所以中间节点在前面，不行就直接false）
为什么迭代比递归难写，因为迭代就是将递归的逻辑展开…
在二叉树：看看这些树的最大深度中我们可以使用层序遍历来求深度，但是就不能直接用层序遍历来求高度了，这就体现出求高度和求深度的不同。
本题的迭代方式可以先定义一个函数，专门用来求高度。getDepth函数通过栈模拟的后序遍历找每一个节点的高度（其实是通过求传入节点为根节点的最大深度来求的高度），如下：
// cur节点的最大深度，就是cur的高度 这个代码也可以用于最大深度那个题目的迭代解法
public int getDepth(TreeNode root){
if (root==null) return 0;
Stack<TreeNode> stack=new Stack<>();
stack.push(root);
int depth=0; // 一定可以进入while循环，到里面再去加 depth++
int result = 0;
while(!stack.isEmpty()){
TreeNode node = stack.peek();
if (null != node){
stack.pop();
stack.push(node);stack.push(null);depth++;
if (node.right != null) stack.push(node.right);
if (node.left != null) stack.push(node.left);
}else{
stack.pop();
node = stack.pop();
depth--;
}
result = Math.max(depth,result);
}
return result;
}
然后再用栈来模拟前序遍历，遍历每一个节点的时候，再去判断左右孩子的高度是否符合，代码如下：
public boolean isBalanced(TreeNode root) {
if (root==null ) return true;
Stack<TreeNode> stack=new Stack<>();
stack.push(root);
while (!stack.isEmpty()){
TreeNode node=stack.pop();
if (node!=null){
if (Math.abs(getDepth(node.left)-getDepth(node.right))>1){
return false;
}
stack.push(node.right);
stack.push(node.left);
}
}
return true; // 能走到这里来就应该返回true
}
整体代码如下：
class Solution {
public int getDepth(TreeNode root){
if (root==null) return 0;
Stack<TreeNode> stack=new Stack<>();
stack.push(root);
int depth=0; // 一定可以进入while循环，到里面再去加 depth++
int result = 0;
while(!stack.isEmpty()){
TreeNode node = stack.peek();
if (null != node){
stack.pop();
stack.push(node);stack.push(null);depth++;
if (node.right != null) stack.push(node.right);
if (node.left != null) stack.push(node.left);
}else{
stack.pop();
node = stack.pop();
depth--;
}
result = Math.max(depth,result);
}
return result;
}
public boolean isBalanced(TreeNode root) {
if (root==null ) return true;
Stack<TreeNode> stack=new Stack<>();
stack.push(root);
while (!stack.isEmpty()){
TreeNode node=stack.pop();
if (node!=null){
if (Math.abs(getDepth(node.left)-getDepth(node.right))>1){
return false;
}
stack.push(node.right);
stack.push(node.left);
}
}
return true; // 能走到这里来就应该返回true
}
}
当然此题用迭代法，其实效率很低，因为没有很好的模拟回溯的过程，所以迭代法有很多重复的计算。
虽然理论上所有的递归都可以用迭代来实现，但是有的场景难度可能比较大。
「例如：都知道回溯法其实就是递归，但是很少人用迭代的方式去实现回溯算法！」
因为对于回溯算法已经是非常复杂的递归了，如果在用迭代的话，就是自己给自己找麻烦，效率也并不一定高。
总结
通过本题可以了解求二叉树深度 和 二叉树高度的差异，求深度适合用前序遍历，而求高度适合用后序遍历，其实都用求高度，都后序遍历就好了，哪有那么麻烦。
本题迭代法其实有点复杂，大家可以有一个思路，也不一定说非要写出来。
但是递归方式是一定要掌握的！
