代码随想录算法训练营：16/60

Ρause

于 2024-06-26 11:56:50 发布

阅读量577

点赞数 23

文章标签：算法深度优先

本文链接：https://blog.csdn.net/qq_44624290/article/details/139985605

版权

一、LeetCode题目

1.LeetCode513:找树左下角的值

题目链接：513. 找树左下角的值 - 力扣（LeetCode）

题目解析

毫无疑问，个人认为层序遍历是最好的方法，好理解，好写；不过这里贴出了学习了用回溯搜索去写，其实就可以理解成，按照指定顺序遍历树，然后在中间满足一定条件更新变量。相当于高级的for循环（bushi），同时也优化了一个比较极致的递归版本，改变了递归条件和递归顺序。

回溯c++代码如下：

/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
* right(right) {}
* };
*/
class Solution {
public:
// 设定搜索是更新的临界目标
int max_depth = INT_MIN;
int target = 0;
// 设定深度搜索函数(其实是回溯函数)
void dfs(TreeNode* root, int depth) {
if (!root)
return;
// 需要的条件：左节点，深度更大。注意！只有满足条件才会更新，要不一直在遍历回溯
if (!root->left && !root->right && max_depth < depth) {
max_depth = depth;
target = root->val;
// 注意不要return，因为要一直更新遍历
}
// 左子树检查
if (root->left) {
dfs(root->left, depth + 1);
}
// 右子树检查
if (root->right) {
dfs(root->right, depth + 1);
}
return;
}
int findBottomLeftValue(TreeNode* root) {
dfs(root, 0);
return target;
}
};

回溯加强版c++代码：

class Solution {
public:
int findBottomLeftValue(TreeNode* root) {
int bottomLeftValue = 0;
int maxDepth = -1;
dfs(root, 0, maxDepth, bottomLeftValue);
return bottomLeftValue;
}
void dfs(TreeNode* node, int depth, int& maxDepth, int& bottomLeftValue) {
if (!node) return;
// 如果当前深度比已知最大深度大，或者当前节点是左节点，更新最大深度和左下角值
if (depth > maxDepth || (depth == maxDepth && node->left)) {
maxDepth = depth;
bottomLeftValue = node->val;
}
// 先遍历右子树，这样左子树的节点会在相同深度下覆盖右子树的节点
if (node->right) dfs(node->right, depth + 1, maxDepth, bottomLeftValue);
if (node->left) dfs(node->left, depth + 1, maxDepth, bottomLeftValue);
}
};

层序遍历c++代码：

/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
* right(right) {}
* };
*/
class Solution {
public:
queue<TreeNode*> que;
vector<vector<int>> result;
int findBottomLeftValue(TreeNode* root) {
que.push(root);
int size = que.size();
while (!que.empty())
{
vector<int> cur_vec;
while (size--)
{
TreeNode* cur_node = que.front();
que.pop();
cur_vec.push_back(cur_node->val);
if (cur_node->left)
que.push(cur_node->left);
if (cur_node->right)
que.push(cur_node->right);
}
result.push_back(cur_vec);
size = que.size();
}
return result.back()[0];
}
};

2.Leetcode112:路径总和

题目链接：112. 路径总和 - 力扣（LeetCode）

题目解析

利用回溯的思想，在遇到叶子节点且满足总和条件的前提下，返回为真。左右子树都检索，最后取一个或，因为返回只要求返回bool只检查又或者没有符合条件路径。

C++代码如下：

/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left),
* right(right) {}
* };
*/
class Solution {
public:
// 回溯搜索路径
bool backtracking(TreeNode* root, int targetSum) {
if (!root)
return false;
if (targetSum == root->val && !root->right && !root->left)
return true;
// backtracking(root->left,targetSum-root->val);
// backtracking(root->right,targetSum - root->val);
return backtracking(root->left, targetSum - root->val) ||
backtracking(root->right, targetSum - root->val);
}
bool hasPathSum(TreeNode* root, int targetSum) {
return backtracking(root, targetSum);
}
};

注意点：这里采用的是值传入，所以没有用显式的回溯过程，那么检验的条件也应该是targetSum == root->val，而不是等于0.

3.Leetcode106:从中序与后序遍历序列构造二叉树

题目链接：106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）

题目解析

大致的思路是：根据后序遍历的结果锁定根节点（末尾），然后用这个值去中序红寻找并切分，这时候问题就会转移到如何根据剩下的这些条件开启下一轮的切分们也就是递归。利用合理的区间构建好左右中序数组之后，可以利用他们的相同长度去切分后序数组，这样就可以得到下一轮的数组。那么根据这个过程，对应的中止条件就是：数组无法切分，即数组为空为止。

C++代码如下：