力扣110. 平衡二叉树（深度、递归）

力扣110. 平衡二叉树（深度、递归）

https://leetcode-cn.com/problems/balanced-binary-tree/

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

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

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

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

    3
   / \
  9  20
    /  \
   15   7
返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

       1
      / \
     2   2
    / \
   3   3
  / \
 4   4
返回 false 。

 

一、从顶至底（暴力法）

思路是构造一个获取当前节点最大深度的方法depthrecursive(root)，通过比较此子树的左右子树的最大高度差(abs(depthrecursive(root->left) - depthrecursive(root->right)) > 1)，来判断此子树是否是二叉平衡树。若树的所有子树都平衡时，此树才平衡。

复杂度分析：
时间复杂度 ：O(log 2N) ， 最差情况下， isBalanced(root) 遍历树所有节点，占用 O(N) ；判断每个节点的最大高度depthrecursive(root)需要遍历各子树的所有节点 ，子树的节点数的复杂度为 O(log 2N) 。
空间复杂度 ：O(N)， 最差情况下（树退化为链表时），系统递归需要使用 O(N) 的栈空间。

bool isBalanced(TreeNode* root)
	{
		//递归终止条件，空结点
		if (root == nullptr)return true;
		if (abs(depthrecursive(root->left) - depthrecursive(root->right)) > 1)return false;
		return isBalanced(root->left) && isBalanced(root->right);
	}

	//递归计算高度
	int depthrecursive(TreeNode* root)
	{
		//递归终止条件，空结点
		if (root == nullptr)return 0;
		return max(depthrecursive(root->left), depthrecursive(root->right)) + 1;
	}

二、从底至顶（提前阻断）

思路是对二叉树做先序遍历，从底至顶返回子树最大高度，若判定某子树不是平衡树则 “剪枝” ，直接向上返回。

复杂度分析：
时间复杂度 ：O(N)， N 为树的节点数；最差情况下，需要递归遍历树的所有节点。
空间复杂度 ：O(N)， 最差情况下（树退化为链表时），系统递归需要使用 O(N) 的栈空间。

//自底向上
	bool isBalanced(TreeNode* root)
	{
		//若 recur(root) != 1 ，则说明此树平衡，返回 true ； 否则返回 false 
		return recursive(root)!=-1;
	}
	int recursive(TreeNode* root)
	{
		//当越过叶子节点时，返回高度 0 
		if (root == nullptr)return 0;
		//左（右）子树高度 left== -1 时，代表此子树的 左（右）子树 不是平衡树，因此直接返回 −1 
		int left = recursive(root->left);
		if (left == -1)return -1;
		int right = recursive(root->right);
		if (right == -1)return -1;
		//当节点root 左 / 右子树的高度差 =<2 ：则返回以节点root为根节点的子树的最大高度，
		//即节点 root 的左右子树中最大高度加 1 （ max(left, right) + 1 ）；。
		//当节点root 左 / 右子树的高度差 ≥2 ：则返回 −1 ，代表此子树不是平衡树
		return abs(left - right) < 2 ? max(left, right) + 1 : -1;
	}

三、汇总

#include "stdafx.h"
#include<queue>
#include<vector>
#include <iostream>
using namespace std;
struct TreeNode
{
	int val;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution
{
public:
	bool isBalanced(TreeNode* root)
	{
		//递归终止条件，空结点
		if (root == nullptr)return true;
		if (abs(depthrecursive(root->left) - depthrecursive(root->right)) > 1)return false;
		return isBalanced(root->left) && isBalanced(root->right);
	}

	//递归计算高度
	int depthrecursive(TreeNode* root)
	{
		//递归终止条件，空结点
		if (root == nullptr)return 0;
		return max(depthrecursive(root->left), depthrecursive(root->right)) + 1;
	}
	//迭代，
	int depthiteration(TreeNode* root)
	{
		return 1;
	}
	//自底向上
	bool isBalancedlow(TreeNode* root)
	{
		//若 recur(root) != 1 ，则说明此树平衡，返回 true ； 否则返回 false 
		return recursive(root)!=-1;
	}
	int recursive(TreeNode* root)
	{
		//当越过叶子节点时，返回高度 0 
		if (root == nullptr)return 0;
		//左（右）子树高度 left== -1 时，代表此子树的 左（右）子树 不是平衡树，因此直接返回 −1 
		int left = recursive(root->left);
		if (left == -1)return -1;
		int right = recursive(root->right);
		if (right == -1)return -1;
		//当节点root 左 / 右子树的高度差 =<2 ：则返回以节点root为根节点的子树的最大高度，
		//即节点 root 的左右子树中最大高度加 1 （ max(left, right) + 1 ）；。
		//当节点root 左 / 右子树的高度差 ≥2 ：则返回 −1 ，代表此子树不是平衡树
		return abs(left - right) < 2 ? max(left, right) + 1 : -1;
	}
};
int main()
{
	TreeNode p[13] = { 2,3,3,4,5,5,4,NULL,NULL,8,9,9,8 };
	p[0].left = &p[1]; p[0].right = &p[2];
	p[1].left = &p[3]; p[1].right = &p[4];
	p[2].left = &p[5]; p[2].right = &p[6];
	//p[3].left = &p[7]; p[3].right = &p[8];
	p[4].left = &p[9]; p[4].right = &p[10];
	p[5].left = &p[11]; p[5].right = &p[12];
	Solution s;
	auto resultrecursive = s.isBalanced(p);
	auto resultrecursivelow = s.isBalancedlow(p);
	return 0;
}