CS_learn/leetcode-master
1
0
Fork 0
mirror of https://github.com/youngyangyang04/leetcode-master.git synced 2026-02-02 18:39:09 +08:00
Code Issues Packages Projects Releases Wiki Activity

Update

Browse Source
This commit is contained in:
programmercarl
2022-09-16 09:40:24 +08:00
parent 697b8ac8e8
commit a64f7a1734
12 changed files with 124 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
problems/0513.找树左下角的值.md
View File

@@ -41,7 +41,7 @@
所以要找深度最大的叶子节点。
那么如果找最左边的呢？可以使用前序遍历，这样才先优先左边搜索，然后记录深度最大的叶子节点，此时就是树的最后一行最左边的值。
那么如果找最左边的呢？可以使用前序遍历（当然中序，后序都可以，因为本题没有 中间节点的处理逻辑，只要左优先就行），保证优先左边搜索，然后记录深度最大的叶子节点，此时就是树的最后一行最左边的值。
递归三部曲：
@@ -49,25 +49,16 @@
参数必须有要遍历的树的根节点，还有就是一个int型的变量用来记录最长深度。 这里就不需要返回值了，所以递归函数的返回类型为void。
本题还需要类里的两个全局变量，maxLen用来记录最大深度，maxleftValue记录最大深度最左节点的数值。
本题还需要类里的两个全局变量，maxLen用来记录最大深度，result记录最大深度最左节点的数值。
代码如下：
```CPP
int maxLen = INT_MIN; // 全局变量 记录最大深度
int maxleftValue; // 全局变量 最大深度最左节点的数值
void traversal(TreeNode* root, int leftLen)
int maxDepth = INT_MIN; // 全局变量 记录最大深度
int result; // 全局变量 最大深度最左节点的数值
void traversal(TreeNode* root, int depth)
```
有的同学可能疑惑，为啥不能递归函数的返回值返回最长深度呢？
其实很多同学都对递归函数什么时候要有返回值，什么时候不能有返回值很迷茫。
**如果需要遍历整棵树，递归函数就不能有返回值。如果需要遍历某一条固定路线，递归函数就一定要有返回值！**
初学者可能对这个结论不太理解，别急，后面我会安排一道题目专门讲递归函数的返回值问题。这里大家暂时先了解一下。
本题我们是要遍历整个树找到最深的叶子节点，需要遍历整棵树，所以递归函数没有返回值。
2. 确定终止条件
@@ -77,9 +68,9 @@ void traversal(TreeNode* root, int leftLen)
```CPP
if (root->left == NULL && root->right == NULL) {
if (leftLen > maxLen) {
maxLen = leftLen; // 更新最大深度
maxleftValue = root->val; // 最大深度最左面的数值
if (depth > maxDepth) {
maxDepth = depth; // 更新最大深度
result = root->val; // 最大深度最左面的数值
}
return;
}
@@ -92,14 +83,14 @@ if (root->left == NULL && root->right == NULL) {
```CPP
// 中
if (root->left) { // 左
leftLen++; // 深度加一
traversal(root->left, leftLen);
leftLen--; // 回溯，深度减一
depth++; // 深度加一
traversal(root->left, depth);
depth--; // 回溯，深度减一
}
if (root->right) { // 右
leftLen++; // 深度加一
traversal(root->right, leftLen);
leftLen--; // 回溯，深度减一
depth++; // 深度加一
traversal(root->right, depth);
depth--; // 回溯，深度减一
}
return;
```
@@ -109,31 +100,31 @@ return;
```CPP
class Solution {
public:
int maxLen = INT_MIN;
int maxleftValue;
void traversal(TreeNode* root, int leftLen) {
int maxDepth = INT_MIN;
int result;
void traversal(TreeNode* root, int depth) {
if (root->left == NULL && root->right == NULL) {
if (leftLen > maxLen) {
maxLen = leftLen;
maxleftValue = root->val;
if (depth > maxDepth) {
maxDepth = depth;
result = root->val;
}
return;
}
if (root->left) {
leftLen++;
traversal(root->left, leftLen);
leftLen--; // 回溯
depth++;
traversal(root->left, depth);
depth--; // 回溯
}
if (root->right) {
leftLen++;
traversal(root->right, leftLen);
leftLen--; // 回溯
depth++;
traversal(root->right, depth);
depth--; // 回溯
}
return;
}
int findBottomLeftValue(TreeNode* root) {
traversal(root, 0);
return maxleftValue;
return result;
}
};
```
@@ -143,27 +134,27 @@ public:
```CPP
class Solution {
public:
int maxLen = INT_MIN;
int maxleftValue;
void traversal(TreeNode* root, int leftLen) {
int maxDepth = INT_MIN;
int result;
void traversal(TreeNode* root, int depth) {
if (root->left == NULL && root->right == NULL) {
if (leftLen > maxLen) {
maxLen = leftLen;
maxleftValue = root->val;
if (depth > maxDepth) {
maxDepth = depth;
result = root->val;
}
return;
}
if (root->left) {
traversal(root->left, leftLen + 1); // 隐藏着回溯
traversal(root->left, depth + 1); // 隐藏着回溯
}
if (root->right) {
traversal(root->right, leftLen + 1); // 隐藏着回溯
traversal(root->right, depth + 1); // 隐藏着回溯
}
return;
}
int findBottomLeftValue(TreeNode* root) {
traversal(root, 0);
return maxleftValue;
return result;
}
};
```
@@ -555,14 +546,14 @@ object Solution {
var maxLeftValue = 0
var maxLen = Int.MinValue
// 递归方法
def traversal(node: TreeNode, leftLen: Int): Unit = {
def traversal(node: TreeNode, depth: Int): Unit = {
// 如果左右都为空并且当前深度大于最大深度，记录最左节点的值
if (node.left == null && node.right == null && leftLen > maxLen) {
maxLen = leftLen
if (node.left == null && node.right == null && depth > maxLen) {
maxLen = depth
maxLeftValue = node.value
}
if (node.left != null) traversal(node.left, leftLen + 1)
if (node.right != null) traversal(node.right, leftLen + 1)
if (node.left != null) traversal(node.left, depth + 1)
if (node.right != null) traversal(node.right, depth + 1)
}
traversal(root, 0) // 调用方法
maxLeftValue // return关键字可以省略