LeetCode 112. 路径总和

1、题目

题目链接：112. 路径总和
给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。
叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。

示例 3：

输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。

提示：

• 树中节点的数目在范围 [0, 5000] 内
• -1000 <= Node.val <= 1000
• -1000 <= targetSum <= 1000

2、深度优先搜索（递归）

思路

观察要求我们完成的函数，我们可以归纳出它的功能：询问是否存在从当前节点 root 到叶子节点的路径，满足其路径和为 targetSum。
假定从根节点到当前节点的值之和为 val，我们可以将这个大问题转化为一个小问题：是否存在从当前节点的子节点到叶子的路径，满足其路径和为 targetSum - val。
不难发现这满足递归的性质，若当前节点就是叶子节点，那么我们直接判断 targetSum 是否等于 val 即可（因为路径和已经确定，就是当前节点的值，我们只需要判断该路径和是否满足条件）。若当前节点不是叶子节点，我们只需要递归地询问它的子节点是否能满足条件即可。

代码

#include <iostream>using namespace std;//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 traversal(TreeNode* root, int count) {// 如果当前节点是叶子节点，并且count为0，则返回trueif (root->left == nullptr && root->right == nullptr && count == 0) {return true;}// 如果当前节点是叶子节点，但count不为0，则返回falseif (root->left == nullptr && root->right == nullptr && count != 0) {return false;}// 如果左子节点存在if (root->left) {// 将count减去左子节点的值count -= root->left->val;// 递归调用traversal函数处理左子树if (traversal(root->left, count)) {// 如果左子树返回true，则直接返回truereturn true;}// 否则，回溯，恢复count的值，继续处理右子树count += root->left->val;}// 如果右子节点存在if (root->right) {// 将count减去右子节点的值count -= root->right->val;// 递归调用traversal函数处理右子树if (traversal(root->right, count)) {// 如果右子树返回true，则直接返回truereturn true;}// 否则，回溯，恢复count的值count += root->right->val;}// 如果左子树和右子树都没有返回true，则返回falsereturn false;}bool hasPathSum(TreeNode* root, int targetSum) {if (root == nullptr) {return false;}return traversal(root, targetSum - root->val);}
};int main() {Solution s;TreeNode* root = new TreeNode(5);root->left = new TreeNode(4);root->right = new TreeNode(8);root->left->left = new TreeNode(11);root->left->left->left = new TreeNode(7);root->left->left->right = new TreeNode(2);root->right->left = new TreeNode(13);root->right->right = new TreeNode(4);root->right->right->left = new TreeNode(5);root->right->right->right = new TreeNode(1);cout << s.hasPathSum(root, 22) << endl;return 0;
}

复杂度分析

• 时间复杂度：O(N)，其中 N 是树的节点数。对每个节点访问一次。
• 空间复杂度：O(H)，其中 H 是树的高度。空间复杂度主要取决于递归时栈空间的开销，最坏情况下，树呈现链状，空间复杂度为 O(N)。平均情况下树的高度与节点数的对数正相关，空间复杂度为 O(log⁡N)。

3、深度优先搜索（递归精简版）

思路

代码

class Solution {
public:bool hasPathSum(TreeNode* root, int targetSum) {// 如果根节点为空，则返回falseif (!root) {return false;}// 如果根节点没有左子节点和右子节点，并且当前节点的值等于目标值，则返回trueif (!root->left && !root->right && targetSum == root->val) {return true;}// 递归地在左子树中查找是否存在路径和为targetSum - 当前节点值的路径// 或者在右子树中查找是否存在路径和为targetSum - 当前节点值的路径return hasPathSum(root->left, targetSum - root->val) || hasPathSum(root->right, targetSum - root->val);}
};

复杂度分析

• 时间复杂度：O(N)，其中 N 是树的节点数。对每个节点访问一次。
• 空间复杂度：O(H)，其中 H 是树的高度。空间复杂度主要取决于递归时栈空间的开销，最坏情况下，树呈现链状，空间复杂度为 O(N)。平均情况下树的高度与节点数的对数正相关，空间复杂度为 O(log⁡N)。

4、广度优先搜索

思路

我们可以想到使用广度优先搜索的方式，记录从根节点到当前节点的路径和，以防止重复计算。
这样我们使用两个队列，分别存储将要遍历的节点，以及根节点到这些节点的路径和即可。

代码

class Solution {
public:bool hasPathSum(TreeNode *root, int sum) {if (root == nullptr) {return false;}// 使用队列存储节点和节点路径和queue<TreeNode *> queNode;queue<int> queVal;queNode.push(root);queVal.push(root->val);while (!queNode.empty()) {// 取出队列头部的节点和路径和TreeNode *now = queNode.front();int temp = queVal.front();queNode.pop();queVal.pop();// 当前节点为叶子节点if (now->left == nullptr && now->right == nullptr) {// 当前路径和等于目标和if (temp == sum) {return true;}continue;}// 当前节点有左子节点if (now->left != nullptr) {queNode.push(now->left);// 将左子节点的路径和加入队列queVal.push(now->left->val + temp);}// 当前节点有右子节点if (now->right != nullptr) {queNode.push(now->right);// 将右子节点的路径和加入队列queVal.push(now->right->val + temp);}}return false;}
};

复杂度分析

• 时间复杂度：O(N)，其中 N 是树的节点数。对每个节点访问一次。
• 空间复杂度：O(N)，其中 N 是树的节点数。空间复杂度主要取决于队列的开销，队列中的元素个数不会超过树的节点数。

LeetCode 113. 路径总和ii

1、题目

题目链接：113. 路径总和 II
给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。
叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：[]

示例 3：

输入：root = [1,2], targetSum = 0
输出：[]

提示：

• 树中节点总数在范围 [0, 5000] 内
• -1000 <= Node.val <= 1000
• -1000 <= targetSum <= 1000

2、深度优先搜索（递归）

思路

我们可以采用深度优先搜索的方式，枚举每一条从根节点到叶子节点的路径。当我们遍历到叶子节点，且此时路径和恰为目标和时，我们就找到了一条满足条件的路径。

代码

class solution {
private:vector<vector<int>> result;vector<int> path;void traversal(TreeNode* cur, int count) {// 如果当前节点为叶子节点且计数为0，则将路径加入结果集并返回if (!cur->left && !cur->right && count == 0) {result.push_back(path);return;}// 如果当前节点为叶子节点，则直接返回if (!cur->left && !cur->right) {return;}// 如果当前节点有左子节点if (cur->left) {// 将左子节点的值加入路径path.push_back(cur->left->val);// 更新计数count -= cur->left->val;// 递归遍历左子节点traversal(cur->left, count);// 恢复计数count += cur->left->val;// 将左子节点的值从路径中移除path.pop_back();}// 如果当前节点有右子节点if (cur->right) {// 将右子节点的值加入路径path.push_back(cur->right->val);// 更新计数count -= cur->right->val;// 递归遍历右子节点traversal(cur->right, count);// 恢复计数count += cur->right->val;// 将右子节点的值从路径中移除path.pop_back();}return ;}public:vector<vector<int>> pathSum(TreeNode* root, int sum) {result.clear();path.clear();// 如果根节点为空，则直接返回空结果if (root == nullptr) {return result;}// 将根节点的值加入路径中path.push_back(root->val);// 调用遍历函数，传入当前节点和剩余的目标和traversal(root, sum - root->val);// 返回最终结果return result;}
};

复杂度分析

• 时间复杂度: O(n^2)
• 空间复杂度: O(n)

3、广度优先搜索

思路

我们也可以采用广度优先搜索的方式，遍历这棵树。当我们遍历到叶子节点，且此时路径和恰为目标和时，我们就找到了一条满足条件的路径。
为了节省空间，我们使用哈希表记录树中的每一个节点的父节点。每次找到一个满足条件的节点，我们就从该节点出发不断向父节点迭代，即可还原出从根节点到当前节点的路径。

代码

class Solution {
public:vector<vector<int>> ret;unordered_map<TreeNode*, TreeNode*> parent;void getPath(TreeNode* node) {// 创建一个临时向量，用于存储路径上的节点值vector<int> tmp;// 当节点不为空时，继续循环while (node != nullptr) {// 将当前节点的值添加到临时向量中tmp.emplace_back(node->val);// 将当前节点更新为其父节点node = parent[node];}// 反转临时向量，使其按从根节点到叶子节点的顺序排列reverse(tmp.begin(), tmp.end());// 将反转后的路径添加到结果向量中ret.emplace_back(tmp);}vector<vector<int>> pathSum(TreeNode* root, int targetSum) {if (root == nullptr) {return ret;}// 使用队列进行广度优先搜索queue<TreeNode*> que_node;queue<int> que_sum;que_node.emplace(root);que_sum.emplace(0);while (!que_node.empty()) {TreeNode* node = que_node.front();que_node.pop();int rec = que_sum.front() + node->val;que_sum.pop();// 如果当前节点是叶子节点if (node->left == nullptr && node->right == nullptr) {// 如果路径和等于目标和if (rec == targetSum) {// 调用getPath函数获取路径getPath(node);}} else {// 如果左子节点不为空if (node->left != nullptr) {// 记录父节点parent[node->left] = node;// 将左子节点和路径和加入队列que_node.emplace(node->left);que_sum.emplace(rec);}// 如果右子节点不为空if (node->right != nullptr) {// 记录父节点parent[node->right] = node;// 将右子节点和路径和加入队列que_node.emplace(node->right);que_sum.emplace(rec);}}}return ret;}
};

复杂度分析

• 时间复杂度: O(n^2)
• 空间复杂度: O(n)