平衡二叉树
题目：给定一个二叉树，判断它是否是高度平衡的二叉树。
高度平衡的二叉树：一个二叉树每个节点的左右两个子树的高度差的绝对值不超过1。
二叉树节点的深度：从根节点到该节点的最长简单路径边的条数
二叉树节点的高度：从该节点带叶子节点的最长简单路径边的条数。
力扣中强调的深度和高度很明显是按照节点来计算的。
关于根节点的深度究竟是1还是0，不同的地方有不同的标准，leetcode的题目中都是以节点为1度，维基百科上定义用边为一度，即根节点的深度是0，以具体题目要求为准
求深度可以从上到下去查，所以需要前序遍历（中左右），而高度只能从下到上去查，所以只能后序遍历（左右中）。
求二叉树根节点的高度 就是 求这棵二叉树的最大深度，所以可以使用后序遍历。
class Solution{
public:
int result;
void getDepth(TreeNode* node,int depth){
result = depth > result ? depth : result;//中
if(node->left == NULL && node->right == NULL)return ;
if(node->left){//左
depth++; //深度+1
getDepth(node->left,depth);
depth--;
}
if(node->right){//右
depth++; //深度+！
getDepth(node->right,depth);
depth--;//回溯，深度-1
}
return ;
}
int maxDepth(TreeNode* root){
result = 0;
if(root == NULL)return result;
getDepth(root,1);
return result;
}
};//简化
class Solution{
public:
int result;
void getDepth(TreeNode* node,int depth){
result = depth > result ? depth : result;//中
if(node->left == NULL&& node->right == NULL)return;
if(node->left){//左
getDepth(node->right,depth + 1);
}
if(node->right){//右
getDepth(node->right,depth + 1);
}
return;
}
int maxDepth(TreeNode* root){
result = 0;
if(root == 0)return result;
getDepth(root,1);
returnresult;
}
};解题思路:
递归
递归三步曲分析：
1.明确递归函数的参数和返回值
参数：当前传入节点。返回值：以当前传入节点为根节点的树的高度。
如何标记左右子树是否差值大于1呢？如果当前传入节点为根节点的二叉树已经不是二叉平衡树了，返回高度没有意义，返回-1来标记已经不符合平衡树的规则了。
代码：
//-1表示已经不是平衡二叉树了，否则返回值是以该节点为根节点树的高度
int getHeight(TreeNode* node);2.明确终止条件
递归的过程中依然是遇到空节点了为终止，返回0，表示当前节点为根节点的树高度为0
if(node == NULL){
return 0;
}3.明确单层递归的逻辑
如何判断以当前传入节点为根节点的二叉树是否是平衡二叉树呢？当然是其左子树高度和其右子树高度的差值。
分别求出其左右子树的高度，然后如果差值小于等于1，则返回当前二叉树的高度，否则返回-1，表示已经不是二叉平衡树了。（函数体中，返回一个return 之后未执行的语句不会再执行，第一个被执行的return意味着函数体的结束）
int leftHeight = getHeight(node->left);//左子树的高度
if(leftHeight == -1)return -1;
int rightHeight = getHeight(node->right);//右子树的高度
if(rightHeight == -1)return -1;
int result;
if(abs(left(leftHeight - rightHeight) > 1)){//左右子树高度差>1，不平衡，返回-1作为标识
result = -1;
}else{
result = 1 + max(leftHeight,rightHeight);//以当前节点为根节点的树的最大高度
}
return result;//代码精简一下
int leftHeight = getHeight(node->left);
if(leftHeight == -1)return -1;
int rightHeight = getHeight(node->right);
if(rightHeight == -1)return -1;
return abs(leftHeight - rightHeight) > 1 ? -1 : 1 + max(leftHeight,rigthHeight);
//getHeight整体代码
int getHeight(TreeNode* node){
if(node == NULL){
return 0;
}
int leftHeight = getHeight(node->left);
if(leftHeight == -1)return -1;
int rightHeight = getHeight(node->right);
if(rightHeight == -1)return -1;
return abs(leftHeight - rightHeight) > 1 ? -1 : 1 + max(leftHeight,rightHeight);
}class Solution{
public:
//返回以该节点为根节点的二叉树的高度，如果不是平衡二叉树了则返回-1
int getHeight(TreeNode* node){
if(node == NULL){
return 0;
}
int leftHeight = getHeight(node->left);
if(leftHeight == -1)return -1;
int rightHeight = getHeight(node->right);
if(rightHeight == -1)return -1;
return abs(leftHeight - rightHeight) > 1 ? -1 : 1 + max(leftHeight,rightHeight);
}
bool isBalanced(TreeNode* root){
return getHeight(root) == -1 ? false : true;
}
};迭代
/*定义一个函数，专门用来求高度
这个函数通过栈模拟的后序遍历找每一个节点的高度（其实是通过求传入节点为根节点的最大深度来求的高度）？*/
//cur节点的最大深度，就是cur的高度
int getDepth(TreeNode* cur){
stack<TreeNode*>st;
if(cur != NULL)st.push(cur);
int depth = 0;//记录深度
int result;
while(!st.empty()){
TreeNode* node = st.top();
if(node != NULL){
st.pop();
st.push(node); //中
st.push(NULL);
depth++;
if(node->right)st.push(node->right);//右
if(node->left)st.push(node->left);//左
}else{
st.pop();
node = st.pop();
st.pop();
depth--;
}
result = result > depth ? result : depth;
}
return result;
}/*然后用栈模拟后序遍历，遍历每个节点的时候，再去判断左右孩子的高度是否符合*/
bool isBalanced(TreeNode* root){
stack<TreeNode*>st;
if(root == NULL)return true;
st.push(root);
while(!st.empty()){
TreeNode* node = st.top(); //中
st.pop();
if(abs(getDepth(node->left)-getDepth(node->right)) > 1){ //判断左右孩子高度是否符合
return false;
}
if(node->right)st.push(node->right);//右（空节点不入栈
if(node->left)st.push(node->left);//左（空节点不入栈）
}
return true;
}此题使用迭代法，其实效率很低，因为没有很好的模拟回溯的过程，所以迭代法有很多重复的计算。
理论上所有递归都可以用迭代实现，但是有的场景难度可能比较大。
都知道回溯法其实就是递归，但是1很少人用递归的方法实现回溯算法！因为回溯算法已经很复杂了，再用迭代就会更复杂，效率不一定高。
求深度可以用前序遍历，求高度可以用后序遍历。
本题迭代会比较复杂。递归较为简单。
二叉树的所有路径
题目：给定一个二叉树，返回所有从根节点到叶子节点的路径。
思路：
要找到所有路径，要找到从根节点到叶子的路径，所以需要前序遍历，这样方便让父节点指向孩子节点，找到对应的路径。
在找到叶子节点后需要记录路径，并且回溯，回退一个路径再进入另一个路径。
递归
递归做前序遍历，递归和回溯常常一起用。
1.递归函数参数及其返回值
要传入根节点，记录每一条路径的path,和存放结果集的result,这里递归不需要返回值。
void traversal(TreeNode* cur,vector<int>& path,vector<string>&result)2.确定递归终止条件
//递归终止条件：找到叶子节点后，（在找到后就开始 结束的处理逻辑了，把路径放进result里）
//也就是cur不为空，并且它的左右孩子都是空的。
if(cur->left == NULL && cur->right == NULL){
//终止处理逻辑
}为什么没有判断cur是否为空呢?因为下面的逻辑可以控制空节点不入循环。
再来看一下终止处理的逻辑。
使用vector结构path来记录路径，所以要把vector结构的path转为string格式，再把这个string放进result里。
那么为什么使用了vector结构来记录路径？因为在下面要回溯，，vector结构方便回溯。
有些代码表面没回溯，其实隐藏在函数调用时的参数赋值里。
终止处理逻辑如下：
if(cur->left == NULL && cur->right == NULL){//遇到叶子节点
string sPath;
for(int i = 0;i < path.size() - 1;i++){//将path里记录的路径转化为string格式
sPath += to_string(path[i]);
sPath += "->";
}
sPath += to_string(path[path.size() - 1]);//记录最后一个节点（叶子节点）
result.push_back(sPath);//收集一个路径
return;
}3.确定单层递归逻辑
因为是前序遍历，需要先处理中间节点，中间节点就是我们要记录路径上的节点，先放进path中。
path.push_back(cur->val);
然后是递归和回溯的过程，上面说过没有判断cur是否为空，那么在这里递归的时候，如果为空就不进行下一层递归了。
所以递归前要加上判断语句，下面要递归的节点是否为空，如下
if(cur->left){
traversal(cur->left,path,result);
}
if(cur->right){
traversal(cur->right,path,result);
}此时还没完，递归完，要回溯，因为path不能一直加入节点，它要删除节点，然后才能加入新的节点。
那么回溯要怎么回溯，回溯和递归是一一对应的，有一个递归，就要有一个回溯，这么写的话，相当于把递归和回溯拆开了，一个在花括号了，一个在花括号外。
所以递归和回溯永远要在一起。
//递归和回溯要写在一起
if(cur->left){
traversal(cur->left,path,result);
path.pop_back();//回溯
}
if(cur->right){
traversal(cur->right,path,result);
path.pop_back();//回溯
}//整体代码，版本一
class Solution{
private:
void traversal(TreeNode* cur,vector<int>&path,vector<string>& result){
path.push_back(cur->val);//中，最后一个节点也要加入path中
//这才到了叶子节点
if(cur->left == NULL && cur->right == NULL){
string sPath;
for(int i = 0;i < path.size() - 1;i++){
sPath += to_string(path[i]);
sPath += "->";
}
sPath += to_string(path[path.size() - 1]);
result.push_back(aPath);
return;
}
if(cur->left){
traversal(cur->left,path,result);
path.pop_back();
}
if(cur->right){
traversal(cur->right,path,result);
path.pop_back();
}
}
public:
vector<string>binaryTreePaths(TreeNode* root){
vector<string>result;
vector<int>path;
if(root == NULL)return result;
traversal(root,path,result);
return result;
}
};//精简后的代码
class Solution {
private:
void traversal(TreeNode* cur, string path, vector<string>& result) {
path += to_string(cur->val); // 中
if (cur->left == NULL && cur->right == NULL) {
result.push_back(path);
return;
}
if (cur->left) traversal(cur->left, path + "->", result); // 左
if (cur->right) traversal(cur->right, path + "->", result); // 右
}
public:
vector<string> binaryTreePaths(TreeNode* root) {
vector<string> result;
string path;
if (root == NULL) return result;
traversal(root, path, result);
return result;
}
};if(cur->left){
path += "->";
traversal(cur->left,path,result);//左
path.pop_back();//回溯‘>’
path.pop_back();//回溯‘-’
}
if(cur->right){
path += "->";
traversal(cur->right,path,right);//右
path.pop_back();//回溯‘>’
path.pop_back();//回溯‘-’
}综合以上，第二种递归的代码虽然精简，但把很多重要的点隐藏在了代码细节里，第一种递归写法虽然代码多一些，但是把每一个逻辑处理都完整的展现出来了。
迭代法
至于非递归的方式，我们可以依然使用前序遍历的迭代方式来模拟遍历路径的过程。
这里除了模拟递归需要一个栈，同时还需要一个栈来存放对应的遍历路径。
class Solution{
public:
vector<string>binaryTreePaths(TreeNode* root){
stack<TreeNode*>treeSt;//保存树的遍历节点
stack<string>pathSt;//保存遍历路径的节点
vector<string>result;//保存最终路径集合
if(root == NULL)return result;
treeSt.push(root);
pathSt.push(to_string(root->val));
while(!treeSt.empty()){
TreeNode* node = treeSt.top();treeSt.pop();
string path = pathSt.top();pathSt.pop();
if(node->left == NULL && node->right == NULL){
result.push_back(path);
}
if(node->right)(
treeSt.push(node->right);
pathSt.push(path + "->" + to_string(node->right->val));
)
}
return result;
}
};左叶子之和
题目：计算给定的所有左叶子之和
思路：首先要注意是判断左叶子，不是二叉树左侧节点，所以不要上来想着层序遍历。
因为题目种没说清楚左叶子究竟是什么节点，那么我来给出左叶子的明确定义：节点A的左孩子不为空，且左孩子的左右孩子都为空（说明是叶子节点），那么A节点的左孩子为左叶子节点
判断当前节点是不是左节点是无法判断的，必须要通过节点的父节点来判断其左孩子是不是左叶子。
如果该节点的左节点不为空，该节点的左节点的左节点为空，该节点的左节点的右节点为空，则找到了一个左叶子。
if(node->left != NULL && node->left->left == NULL && node->left->right == NULL){
//左叶子节点处理逻辑
}递归法
递归的遍历顺序为后序遍历（左右中），是因为要通过递归函数的返回值来累加求取左叶子数值之和。
1.确定递归函数的参数和返回值
判断一个树的左叶子点之和，那么一定要传入树的根节点，递归函数的返回值为数值之和，所以为int使用题目中给出的函数就可以了。
2.确定终止条件
如果遍历到空节点，那么左叶子值一定是0
if(root == NULL) return 0;注意，只有当前遍历的节点是父节点，才能判断其子节点是不是左叶子。所以如果当前遍历的节点是叶子节点，那其左叶子也必定是0，那么终止条件为：
if(root == NULL)return 0;
if(root->left == NULL && root->right == NULL)return 0;//其实这个也可以不写，如果不写不影响结果，但就会让递归多进行了一层。3.确定单层递归的逻辑
当遇到左叶子节点的时候，记录数值，然后通过递归求取左子树左叶子之和，和右子树左叶子之和，相加便是整个树的左叶子之和。
代码：
int leftValue = sumOfLeftLeaves(root->left);//左
if(root->left && !root->left->left && !root->left->right){
leftValue = root->left->val;
}
int rightValue = sumOfLeftLeave(root->right);
int sum = leftValue + rightValue;
return sum;//整体递归代码如下
classSolution{
public:
int sumOfLeftLeaves(TreeNode* root){
if(root == NULL)return 0;
if(root->left == NULL && root->right == NULL)return 0;
int leftValue = sumOfLeftLeaves(root->left);
if(root->left && !root->left->left && !root->left->right){
leftValue = root->left->val;
}
int rightValue = sumOfLeftLeaves(root->right);
int sum = leftValue + rightValue;
return sum;
}
};//精简一下
class Solution{
public:
int sumOfLeftLeaves(TreeNode* root){
if(root == NULL)return 0;
int leftValue = 0;
if(root->left != NULL && root->left->left == NULL && root->left->right == NULL){
leftValue = root->left->val;
}
return leftValue + sumOfLeftLeaves(root->left) + sumOfLeftLeaves(root->right);
}
};迭代法
class Solution{
public:
int sumOfLeftLeaves(TreeNode* root){
stack<TreeNode*>st;
if(root == NULL)return 0;
st.push(root);
int result = 0;
while(!st.empty()){
TreeNode* node = st.top();
st.pop();
if(node->left != NULL && node->left->left == NULL && node->left->right == NULL){
result += node->left->val;
}
if(node->right)st.push(node->right);
if(node->left)st.push(node->left);
}
return result;
}
};总结
要通过节点的父节点来判断其左孩子是不是左叶子了。
平时我们解二叉树的题目时，已经习惯了通过节点的左右孩子判断本节点的属性，而本题我们要通过节点的父节点判断本节点的属性。
24
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
