1、leetcode 110：平衡二叉树
1.1 后序遍历求高度：递归
后序递归求高度
class Solution {
public:
bool judge = 1;
int order(TreeNode* cur) {
if(cur == nullptr) {
return 0;
}
int left = order(cur->left);
int right = order(cur->right);
if(max(left, right) - min(left, right) > 1) {
judge = 0;
}
return max(left, right) + 1;
}
bool isBalanced(TreeNode* root) {
//后序遍历，比较左右子树的高度
order(root);
return judge;
}
};
平衡二叉树要求比较高度，必然是要后序遍历
递归三步曲：
1、明确递归函数的参数和返回值
参数：当前传入节点
返回值：以当前传入节点为根节点的树的高度
那么如何标记左右子树是否差值大于1呢
如果当前传入节点为根节点的二叉树已经不是二叉平衡树了，还返回高度的话就没有意义了
所以如果已经不是二叉平衡树了，可以返回-1 来标记已经不符合平衡树的规则了
2、明确终止条件
递归的过程中依然是遇到空节点了为终止，返回0，表示当前节点为根节点的树高度为0
3、明确单层递归的逻辑
如何判断以当前传入节点为根节点的二叉树是否是平衡二叉树呢？当然是其左子树高度和其右子树高度的差值
分别求出其左右子树的高度，然后如果差值小于等于1，则返回当前二叉树的高度，否则返回-1，表示已经不是二叉平衡树了
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;
}
};
1.2 后序遍历求高度（最大实时深度）：迭代，思路与1.1不同
不能直接用层序遍历来求高度了，这就体现出求高度和求深度的不同
本题的迭代方式可以先定义一个函数，专门用迭代法来求高度
后序遍历实时只能求 深度，求不了高度，但是最大深度 就等于 高度
这个函数通过栈模拟的后序遍历找每一个节点的高度（其实是通过求传入节点为根节点的 深度来求的高度），然后再使用一种遍历方法遍历到所有节点对每个节点进行判断就行了
知道思路写代码，是使用统一迭代的后序遍历求每个节点的高度（这个只能后序遍历求，对于每个节点来说高度和深度不等），遍历每个节点进行判断也是使用的统一迭代的后序遍历
注意height的加减，注意注释
class Solution {
public:
int getHeight(TreeNode* cur) {//求高度前序后序都行
if(cur == nullptr) return 0;
stack<TreeNode*> mystack;
mystack.push(cur);
int height = 0;//记录过程中的高度
int result = 0;//记录最终高度，也就是过程中出现过的 最高 高度
while(!mystack.empty()) {
TreeNode* tmp = mystack.top();
mystack.pop();
if(tmp != nullptr) {
mystack.push(tmp);
mystack.push(nullptr);//这边统一迭代法需要先把中间节点入栈，这边直接就是第二次对中间节点的遍历了，而不是放在两个if后面
height++;//第一次tmp弹出的时候是第一次遍历到，往里面加了下一层的一个节点 深度+1，因为每次是挑一棵树一路往下钻
if(height > result) {
result = height;
}
if(tmp->right) mystack.push(tmp->right);
if(tmp->left) mystack.push(tmp->left);
}
else {
height--;//第二次弹出之后就返回父节点了，所以深度-1，就算 下一个节点是一层上的，也是前面没有空指针的，自己会加1，相当于在这一步也回到了 父节点
mystack.pop();
}
}
return result;
}
bool isBalanced(TreeNode* root) {
//后序遍历，比较左右子树的高度(啥遍历方式无所谓，只要把节点遍历一遍即可)
if(root == nullptr) return true;
stack<TreeNode*> mystack;
mystack.push(root);
while(!mystack.empty()) {
TreeNode* tmp = mystack.top();
mystack.pop();
if(tmp != nullptr) {
mystack.push(tmp);
mystack.push(nullptr);
if(tmp->right) mystack.push(tmp->right);
if(tmp->left) mystack.push(tmp->left);
}
else {
//注意先弹出的是空指针，要让tmp指向待处理的元素
tmp = mystack.top();
if(abs(getHeight(tmp->left) - getHeight(tmp->right)) > 1) {
return false;
}
mystack.pop();
}
}
return true;
}
};
遍历每个节点进行判断也是使用的非统一迭代的中序遍历
class Solution {
public:
int getHeight(TreeNode* cur) {
stack<TreeNode*> sta;
int res = 0;
int height = 0;
if (cur) sta.push(cur);
while (!sta.empty()) {
TreeNode* tmp = sta.top();
sta.pop();
if (tmp != nullptr) {
sta.push(tmp);
sta.push(nullptr);
height++;
if (tmp->right) sta.push(tmp->right);
if (tmp->left) sta.push(tmp->left);
}
else {
sta.pop();
height--;
}
res = res < height ? height : res;
}
return res;
}
bool isBalanced(TreeNode* root) {
stack<TreeNode*> sta;
TreeNode* cur = root;
bool judge = 1;
while (!sta.empty() || cur != nullptr) {
if (cur != nullptr) {
sta.push(cur);
cur = cur->left;
}
else {
TreeNode* tmp = sta.top();
sta.pop();
if (abs(getHeight(tmp->left) - getHeight(tmp->right)) > 1)
return false;
cur = tmp->right;
}
}
return true;
}
};
代码随想录代码，是使用统一迭代的后序遍历求每个节点的高度（这个只能后序遍历求，对于每个节点来说高度和宽度不等），遍历每个节点进行判断是使用的非统一迭代的先序遍历
class Solution {
private:
int getDepth(TreeNode* cur) {
stack<TreeNode*> st;
if (cur != NULL) st.push(cur);
int depth = 0; // 记录深度
int result = 0;
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.top();
st.pop();
depth--;
}
result = result > depth ? result : depth;
}
return result;
}
public:
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;
}
};
当然此题用迭代法，其实效率很低，因为没有很好的模拟回溯的过程，所以迭代法有很多重复的计算
虽然理论上所有的递归都可以用迭代来实现，但是有的场景难度可能比较大
例如：都知道回溯法其实就是递归，但是很少人用迭代的方式去实现回溯算法
因为对于回溯算法已经是非常复杂的递归了，如果再用迭代的话，就是自己给自己找麻烦，效率也并不一定高
2、leetcode 257：二叉树的所有路径
2.1 前序遍历：回溯+递归，int转string
第一遍代码，前序遍历，用回溯的方法，对于本次回溯使用的逻辑而言，被回溯的递归函数参数直接改的话，不需要加&符号（后面代码随想录的代码就加上引用号了），因为就是一个形参，不需要保留单层函数对那个参数的改变（更方便回溯）
tmp += (char)(root->val + '0');将root->val 从int->char，但是这样处理不了负数
将int 转 string应该用to_string函数
class Solution {
public:
vector<string> result;
void findpath(TreeNode* root, string tmp) {
if(root->left == nullptr && root->right == nullptr) {//注意终止条件
tmp += to_string(root->val);
result.push_back(tmp);
return;
}
//tmp += (char)(root->val + '0');//将root->val从int->char，但是这样处理不了负数
//将int转string应该用to_string函数
tmp += to_string(root->val);
if(root->left) {
tmp += '-';
tmp += '>'; // 将添加箭头 与 递归函数添加节点 区分开来，递归函数只添加节点
findpath(root->left, tmp);
tmp.erase(tmp.end()-2, tmp.end()); // 擦除箭头
}
if(root->right) {
tmp += '-';
tmp += '>';
findpath(root->right, tmp);
tmp.erase(tmp.end()-2, tmp.end());
}
}
vector<string> binaryTreePaths(TreeNode* root) {
string a = "";
findpath(root, a);
return result;
}
};
这道题目要求从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径
在这道题目中将第一次涉及到回溯，因为我们要把路径记录下来，需要回溯来回退一个路径再进入另一个路径（与第一次代码思路一致）
前序遍历以及回溯的过程如图：
递归和回溯就是一家的，本题也需要回溯
递归三部曲：
1、递归函数参数以及返回值
要传入根节点，记录每一条路径的path，和存放结果集的result，这里递归不需要返回值，代码如下：
void traversal(TreeNode* cur, vector<int>& path, vector<string>& result)
2、确定递归终止条件
在写递归的时候都习惯了这么写：
if (cur == NULL) {
终止处理逻辑
}
但是本题的终止条件这样写会很麻烦，因为本题要找到叶子节点，就开始结束的处理逻辑了（把路径放进result里），因为之后要回退回叶子节点的父节点，所以到叶子节点就要停了
那么什么时候算是找到了叶子节点？ 是当cur不为空，其左右孩子都为空的时候，就找到叶子节点
所以本题的终止条件是：
if (cur->left == NULL && cur->right == NULL) {
终止处理逻辑
}
为什么没有判断cur是否为空呢，因为下面的单层递归逻辑（if(cur->left) && if(cur->right)）可以控制空节点不入循环
这里使用vector结构path来记录路径，所以要把vector结构的path转为string格式，再把这个string放进result里
将添加 / 删除箭头 与 递归函数添加节点 区分开来，递归函数 负责节点
那么为什么使用了vector结构来记录路径呢？因为在下面处理单层递归逻辑的时候，要做回溯，使用vector方便来做回溯，回溯隐藏在函数调用时的参数赋值里（第一遍代码就是使用string直接作为回溯的数据结构，更麻烦些）
如果使用vector结构的path容器来记录路径，那么终止处理逻辑如下：
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)才入栈），下面要递归的节点是否为空，如下（还没写对应回溯逻辑）
if (cur->left) {
traversal(cur->left, path, result);
}
if (cur->right) {
traversal(cur->right, path, result);
}
回溯和递归是一一对应的，有一个递归，就要有一个回溯；所以回溯要和递归永远在一起（在一个大括号里）（回溯逻辑完成）
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;//把vector中记录的节点转成路线的string形式
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(sPath);
return;
}
if (cur->left) { // 左
traversal(cur->left, path, result);
path.pop_back(); // 回溯（体现出只用vector记录节点的方便性）
}
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;//vector里面是不允许有空节点的
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;
}
};
注意在函数定义的时候void traversal(TreeNode* cur, string path, vector<string>& result) ，定义的是string path，每次都是复制赋值，不用使用引用，否则就无法做到回溯的效果
那么在如上代码中，貌似没有看到回溯的逻辑，其实不然，回溯就隐藏在traversal(cur->left, path + "->", result);中的 path + "->"。 每次函数调用完，path依然是没有加上"->" 的，这就是回溯了
另一种写法：
if (cur->left) {
path += "->";
traversal(cur->left, path, result); // 左
path.pop_back(); // 回溯 '>'
path.pop_back(); // 回溯 '-'
}
if (cur->right) {
path += "->";
traversal(cur->right, path, result); // 右
path.pop_back(); // 回溯 '>'
path.pop_back(); // 回溯 '-'
}
如果把 path + "->"作为函数参数就是可以的，因为并没有改变path的数值，执行完递归函数之后，path依然是之前的数值（相当于回溯了）
在上面代码中，其实仅仅是回溯了 -> 部分（调用两次pop_back，一次pop “>”， 一次pop “-”），大家应该疑惑那么 path += to_string(cur->val); 这一步为什么没有回溯呢？ 一条路径能持续加节点不做回溯吗？
其实关键还在于参数，使用的是string path，这里并没有加上引用& ，即本层递归中，path + 该节点数值，但该层递归结束，上一层path的数值并不会受到任何影响。 如图所示：
节点4的path，在遍历到节点3，path+3，遍历节点3的递归结束之后，返回节点4（回溯的过程），path并不会把3加上
所以这是参数中，不带引用，不做地址拷贝，只做内容拷贝的效果
在代码随想录的第一段代码中，函数参数就使用了引用，即 vector<int>& path ，这是会拷贝地址的，所以本层递归逻辑如果有path.push_back(cur->val); 就一定要有对应的path.pop_back()
为什么不去定义一个 string& path 这样的函数参数呢，然后也可能在递归函数中展现回溯的过程，但关键在于，path += to_string(cur->val); 每次是加上一个数字，这个数字如果是个位数，那好说，就调用一次path.pop_back()，但如果是十位数，百位数，千位数呢？ 百位数就要调用三次path.pop_back()，才能实现对应的回溯操作，这样代码实现就太冗余了
所以，第一个代码版本中，我才使用 vector类型的path，这样方便给大家演示代码中回溯的操作。 vector类型的path，不管每次路径收集的数字是几位数，总之一定是int，所以就一次pop_back就可以，这就是为什么说vector递归更方便的原因
2.2 前序遍历：迭代
至于非递归的方式，我们可以依然可以使用前序遍历的迭代方式来模拟遍历路径的过程
这里除了模拟递归需要一个栈，同时还需要一个栈来存放对应的遍历路径，每次有进展就弹出旧元素，往那个栈里压新的元素（对弹出元素进行修改，加入新的节点）
代码随想录代码：
class Solution {
public:
vector<string> binaryTreePaths(TreeNode* root) {
stack<TreeNode*> treeSt;// 保存树的遍历节点，记录有可能可以通到终点的路线 的当前已记录进pathSt的 最后一个节点
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));
}
if (node->left) { // 左
treeSt.push(node->left);
pathSt.push(path + "->" + to_string(node->left->val));
}
}
return result;
}
};
3、leetcode 404：左叶子之和
3.1 前序遍历：非统一迭代
第一遍代码，非统一迭代前序遍历
if(root->left == nullptr) return 0;
错了，可能右子树有左叶子节点
class Solution {
public:
int sumOfLeftLeaves(TreeNode* root) {//前序遍历
stack<TreeNode*> mystack;
if(root == nullptr) return 0;
//if(root->left == nullptr) return 0;错了，可能右子树有左叶子节点
mystack.push(root);
int sum = 0;
while(!mystack.empty()) {
TreeNode* tmp = mystack.top();
mystack.pop();
if(tmp->right) {
mystack.push(tmp->right);
}
if(tmp->left) {
if(tmp->left->left == nullptr && tmp->left->right == nullptr) {
sum += tmp->left->val;
}
mystack.push(tmp->left);
}
}
return sum;
}
};
首先要注意是判断左叶子，不是二叉树左侧节点，所以不要上来想着层序遍历
因为题目中其实没有说清楚左叶子究竟是什么节点，那么我来给出左叶子的明确定义：节点A的左孩子不为空，且左孩子的左右孩子都为空（说明是叶子节点），那么A节点的左孩子为左叶子节点
判断当前节点是不是左叶子是无法判断的，必须要通过节点的父节点来判断其左孩子是不是左叶子
如果该节点的左节点不为空，该节点的左节点的左节点为空，该节点的左节点的右节点为空，则找到了一个左叶子，判断代码如下：
if (node->left != NULL && node->left->left == NULL && node->left->right == NULL) {
左叶子节点处理逻辑
}
3.2 后序遍历：递归
递归法（以后序遍历为例，与后序遍历写法一致）
选取的递归遍历顺序为后序遍历（左右中），所以要通过递归函数的返回值来累加求取左叶子数值之和
递归三部曲：
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 = sumOfLeftLeaves(root->right); // 右
int sum = leftValue + rightValue; // 中
return sum;
总体代码：
class Solution {
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;
}
};
实现错误代码
如图：
root = [3,9,20,null,null,15,7] 下面代码运行结果是 9，只计算了左子树上的直接返回了
class Solution {
public:
int sumOfLeftLeaves(TreeNode* root) {
if (root == nullptr) return 0;
if (!root->left && !root->right) return 0;
if (root->left && root->left->left == nullptr && root->left->right == nullptr) {
return root->left->val; //应该是对leftNum求值的修正
}
int leftNum = sumOfLeftLeaves(root->left);
int rightNum = sumOfLeftLeaves(root->right);
return leftNum + rightNum;
}
};
3.3 总结
这道题目要求左叶子之和，其实是比较绕的，因为不能判断本节点是不是左叶子节点
此时就要通过节点的父节点来判断其左孩子是不是左叶子了
平时我们解二叉树的题目时，已经习惯了通过节点的左右孩子判断本节点的属性，而本题我们要通过节点的父节点判断本节点的属性
238
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
