平衡二叉树
题目:给定一个二叉树,判断它是否是高度平衡的二叉树。
高度平衡的二叉树:一个二叉树每个节点的左右两个子树的高度差的绝对值不超过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;
}
};
总结
要通过节点的父节点来判断其左孩子是不是左叶子了。
平时我们解二叉树的题目时,已经习惯了通过节点的左右孩子判断本节点的属性,而本题我们要通过节点的父节点判断本节点的属性。