力扣112. 路径总和

最新推荐文章于 2025-11-24 14:44:53 发布
原创 最新推荐文章于 2025-11-24 14:44:53 发布 · 149 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#leetcode #算法 #数据结构 #二叉树

正常版

/**
 * 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 hasPathSum(TreeNode* root, int targetSum) {
        if(!root) return false;
        return traversal(root, targetSum - root->val);
    }
private:
    bool traversal(TreeNode* node, int count) const {
        if(!node->left && !node->right) {
            if(!count) return true;
            if(count) return false;
        }
        if(node->left) {
            if(traversal(node->left, count - node->left->val)) return true;
        }
        if(node->right) {
            if(traversal(node->right, count - node->right->val)) return true;
        }
        return false;
    }
};

精简版

/**
 * 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 hasPathSum(TreeNode* root, int targetSum) {
        if(!root) return false;
        if(!root->left && !root->right) return root->val == targetSum;
        return (hasPathSum(root->left, targetSum - root->val)) || (hasPathSum(root->right, targetSum - root->val));
    }
};
112. 路径总和（二叉树算法题）
m0_68880377的博客
10-02 572
该题目要求判断二叉树中是否存在从根节点到叶子节点的路径和等于给定目标值。使用迭代法DFS解决，通过两个栈分别存储节点和对应的路径和。当遇到叶子节点且路径和等于目标值时返回true，否则继续遍历。算法时间复杂度O(n)，空间复杂度O(n)。关键点在于栈的同步操作和叶子节点的判断条件。
刷穿力扣 | 437. 路径总和 III（一道很多细节的算法题）
程序员大航子
01-05 545
元旦做了一个决定，算法是我必须要深入的一门手艺，所以我会要求自己，坚持刷题，而且难题一定要抽出时间死磕。 题目 原题链接：点击这里 难度：中等 思路 这道题，说老实话，上来我的思路就很明确，dfs就能解，并且在白板上两分钟就截了出来。但是我知道这一定不是最优解，很遗憾，我没能自己想出最优解，看了解题很久才明白过来，这是一道很有技巧的算法题，这里会把两种解法都贴出来，dfs和前缀和。 所谓dfs暴力解法，就是穷举所有节点为路径和的初始节点，然后向下递归，每一个节点作为路径和的初始节点有多少满足情况的，再.
力扣112.路径总和
2301_80505422的博客
11-15 452
这题的思路跟求二叉树最大深度有相似之处，只需要增加一个参数，在遍历左右节点的同时将增加的参数与该节点的val值作差，并判断在叶子节点时该参数是否为0，如果是0则表示该路径和为题目给的目标值，当所有节点都遍历完后如果没有和为目标值的路径，才返回false。不存在 sum = 5 的根节点到叶子节点的路径。由于树是空的，所以不存在根节点到叶子节点的路径。的路径，这条路径上所有节点值相加等于目标和。等于目标和的根节点到叶节点路径如上图所示。和一个表示目标和的整数。是指没有子节点的节点。
力扣 112.路径总和
qq_73586673的博客
11-17 308
给你二叉树的根节点root和一个表示目标和的整数targetSum。判断该树中是否存在的路径，这条路径上所有节点值相加等于目标和targetSum。如果存在，返回true；否则，返回false。是指没有子节点的节点。true等于目标和的根节点到叶节点路径如上图所示。false树中存在两条根节点到叶子节点的路径：(1 --> 2): 和为 3(1 --> 3): 和为 4不存在 sum = 5 的根节点到叶子节点的路径。false由于树是空的，所以不存在根节点到叶子节点的路径。
力扣 112. 路径总和
2301_76742087的博客
05-05 438
不存在 sum = 5 的根节点到叶子节点的路径。由于树是空的，所以不存在根节点到叶子节点的路径。的路径，这条路径上所有节点值相加等于目标和。等于目标和的根节点到叶节点路径如上图所示。(1 --> 2): 和为 3。(1 --> 3): 和为 4。和一个表示目标和的整数。是指没有子节点的节点。
【力扣】112. 路径总和
qq_40297054的博客
02-02 337
112. 路径总和
力扣：112. 路径总和
qq_46111138的博客
05-27 346
题目链接：112. 路径总和 题目： 给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。 叶子节点 是指没有子节点的节点。 示例 1： 输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22 输出：true 解释：等于目标和的根节点到叶节点
二叉树：力扣 112.路径总和
qq_45782471的博客
04-26 706
给你二叉树的根节点root和一个表示目标和的整数targetSum。判断该树中是否存在的路径，这条路径上所有节点值相加等于目标和targetSum。如果存在，返回true；否则，返回false。是指没有子节点的节点。
力扣(Leetcode)112. 路径总和(JAVA)
zzb1580的博客
11-08 474
本题解法基于二叉树所有路径的解法上修改而成，可以视作是一道题一起进行记忆。
迭代法（迭代+栈）模拟递归实现深度优先搜索（DFS）：以力扣原题[112. 路径总和]及[113. 路径总和 II]为例
bluecyan的博客
04-14 938
如果直接将 road 作为参数，因为是传引用，子递归对 road 的改变将直接影响上层递归中 road 的值（毕竟自始至终都是在对同一个对象做操作），如果要以用 road 做参数的方式实现回溯，需要在传递 road 时 new 一个新的对象，新对象即是子递归需要的新 road，将新对象作为参数传递给子递归函数，这样，每次递归调用时传入的 road 都不同，子递归对 road 的改变也就不会影响上层递归中 road 的值了。在状态转移中有一个深度优先搜索中重之又重的概念：回溯。
LeetCode·113.路径总和||·递归回溯
m0_64560763的博客
08-25 482
递归·回溯
力扣64. 最小路径和（动态规划）
小麦China的博客
10-21 427
力扣64. 最小路径和（动态规划） 动态规划 由于路径的方向只能是向下或向右， 网格的第一行的每个元素只能从左上角元素开始向右移动到达 网格的第一列的每个元素只能从左上角元素开始向下移动到达，前两点的路径是唯一的，因此每个元素对应的最小路径和即为对应的路径上的数字总和。 对于不在第一行和第一列的元素，可以从其上方相邻元素向下移动一步到达，或者从其左方相邻元素向右移动一步到达，元素对应的最小路径和等于其上方相邻元素与其左方相邻元素两者对应的最小路径和中的最小值加上当前元素的值。 由于每个元素对应
leetcode 757
2301_77892984的博客
11-20 144
757: 设置交集大小至少为2。
LeetCode 每日一题 2025/11/17-2025/11/23
AlphaTao的博客
11-23 398
记录了初步解题思路 以及本地实现代码；并不一定为最优 也希望大家能一起探讨 一起进步
【LeetCode Hot100----12-堆(01-04),包含多种方法，详细思路与代码，让你一篇文章看懂所有！】
xxxxxxllllllshi的博客
11-24 20
本文介绍了堆数据结构的核心特性与操作实现。堆是一种完全二叉树，分为最大堆（父节点≥子节点）和最小堆（父节点≤子节点），通过数组存储可实现高效极值操作（O(log n)）。文章详细展示了最小堆的Java实现，包括插入元素（上浮操作）、删除堆顶（下沉操作）和堆化过程，并提供了数组索引映射公式。此外，还介绍了Java内置的PriorityQueue类，可直接用作最小堆或通过自定义比较器实现最大堆，适用于LeetCode等算法题目中动态维护极值的场景。
Leetcode 全排列 题解
lxh0113的博客
11-24 218
1. 需要理解 dfs，利用 book 数组标记已经 排列过的元素，在遍历之前，找到没排列的数组，并记录预存的结果，一层一层遍历当前位置的可能性，知道遍历到所有的位置，但需要注意 js 的一个点是 对于复杂类型参数传递是 地址传递，所以在最后push到结果数组的时候，需要拷贝该数组的值，否则结果数组就会变成 全是 空数组。这个全排列要求的是 不重复排列，这里我们只要考虑到，每个位置的 值，我们只要不重复 往下迭代就行，所以我们利用 set 去记录已经遍历的值，只有没出现的才往下迭代就行。
力扣hot100 - 合并两个有序链表21
2401_82978699的博客
11-22 147
本文实现了一个合并两个有序链表的算法。通过使用哨兵节点(dummy)简化边界条件处理，算法比较两个链表的当前节点值，将较小值的节点连接到结果链表尾部。当任一链表遍历完后，直接将剩余部分链接到结果链表。时间复杂度为O(n+m)，空间复杂度为O(1)。代码包含完整的测试用例和内存管理辅助函数，展示了如何创建、打印和释放链表，并提供了三个测试示例验证算法正确性。
leetcode 1262
最新发布
2301_77892984的博客
11-24 148
初始值 f[0]=[0,−∞,−∞]，翻译自 dfs(−1,0)=0,dfs(−1,1)=−∞,dfs(−1,2)=−∞。注意，如果 (j−x)mod3<0，需要再 +3 调整到 [0,2] 内。定义 dfs(i,j) 表示从 nums[0] 到 nums[i] 中选数，（注意这里的定义是已经选的，上面定义的是还需要选的。的数字之和 s 满足 smod3=j 的前提下，s 的最大值。答案为 f[n][0]，翻译自 dfs(n−1,0)。思路：dp动态规划（选or不选）递归入口：dfs(n−1,0)。
力扣112题C语言实现
04-20
<think>好的，我现在需要帮用户查找力扣112题的C语言实现代码或解决方案。首先，我要确定题目112是什么内容。力扣112题是“路径总和”，题目要求判断二叉树中是否存在从根节点到叶子节点的路径，使得路径上所有节点的值之和等于给定的目标和。 接下来，我得回忆一下解决这个问题的常见方法。通常，二叉树的问题可以用递归、迭代或者Morris遍历来解决。用户需要C语言的实现，所以我应该用C的语法结构来编写代码。根据引用[1]提到的解决方案，递归方法的时间复杂度是$O(n)$，空间复杂度也是$O(n)$，因为函数调用栈的深度可能达到树的高度。而迭代方法通常使用栈，空间复杂度同样是$O(n)$。Morris遍历虽然空间复杂度为$O(1)$，但实现起来比较复杂，可能不太适合初学者。 用户可能更倾向于简单易懂的解法，所以先考虑递归方法。递归的思路是，从根节点开始，每次递归减去当前节点的值，然后判断左右子树是否存在满足条件的路径。如果当前节点是叶子节点，并且剩下的目标和等于当前节点的值，则返回true。否则，递归检查左右子树。 然后是迭代方法，使用栈来模拟递归过程。需要记录当前节点和剩余的目标和。每次处理一个节点时，如果是叶子节点且剩余和等于节点值，返回true。否则，将左右子节点和新的剩余和压入栈中继续处理。 接下来，我需要检查C语言中二叉树的结构定义。通常，力扣的题目中二叉树节点定义为： struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; }; 接下来编写递归版本的代码。递归函数需要当前节点和剩余和作为参数。如果当前节点为空，返回false。如果是叶子节点，检查剩余和是否等于节点值。否则，递归处理左右子树，注意减去当前节点的值。 然后是迭代版本的实现，使用栈结构。由于C语言没有内置栈，需要自己实现。可以使用结构体数组来模拟栈，每个元素包含节点指针和剩余的和。处理时，弹出栈顶元素，判断是否为叶子节点且满足条件。否则，将左右子节点压入栈，同时更新剩余的和。 在编写代码时，需要注意边界条件，例如空树的情况。此外，栈的大小需要足够大，这里假设树的最大节点数为100，根据引用[1]中提到节点数目在范围[0, 100]内，所以栈的大小设为100足够。 用户可能需要两种方法的比较，比如时间空间复杂度，或者不同方法的适用场景。例如递归方法代码简洁，但可能栈溢出；迭代方法显式使用栈，更可控；Morris遍历节省空间但实现复杂。不过用户要求C语言实现，可能更关注代码的正确性和效率。 最后，确保代码符合C语言的语法，比如结构体的使用，指针操作，以及布尔类型的处理。在C语言中，需要使用stdbool.h头文件来使用bool类型。 总结下来，我需要提供递归和迭代两种C语言实现，并简要解释思路，确保用户能够理解并应用。</think>### 力扣112题（路径总和）C语言实现 #### 题目要求 判断二叉树中是否存在从根节点到叶子节点的路径，使得路径节点值之和等于给定目标值。 #### 算法思路 1. **递归法**：深度优先遍历二叉树，逐层减少目标值，判断叶子节点是否满足条件[^1]。 2. **迭代法**：使用栈模拟递归过程，显式存储节点路径和剩余目标值[^1]。 --- #### C语言实现代码 ##### 1. 递归法 ```c #include <stdbool.h> struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; }; bool hasPathSum(struct TreeNode* root, int targetSum) { if (root == NULL) return false; // 判断是否为叶子节点且满足条件 if (root->left == NULL && root->right == NULL) { return (targetSum == root->val); } // 递归检查左右子树 return hasPathSum(root->left, targetSum - root->val) || hasPathSum(root->right, targetSum - root->val); } ``` ##### 2. 迭代法（栈实现） ```c #include <stdbool.h> #define MAX_SIZE 100 // 根据题目约束设定栈大小[^1] struct StackNode { struct TreeNode* node; int remaining; }; bool hasPathSum(struct TreeNode* root, int targetSum) { if (root == NULL) return false; struct StackNode stack[MAX_SIZE]; int top = -1; // 初始化栈（根节点入栈） stack[++top] = (struct StackNode){root, targetSum}; while (top >= 0) { struct StackNode current = stack[top--]; struct TreeNode* node = current.node; int remaining = current.remaining - node->val; // 判断叶子节点是否满足条件 if (node->left == NULL && node->right == NULL && remaining == 0) { return true; } // 右子节点入栈 if (node->right != NULL) { stack[++top] = (struct StackNode){node->right, remaining}; } // 左子节点入栈 if (node->left != NULL) { stack[++top] = (struct StackNode){node->left, remaining}; } } return false; } ``` --- #### 复杂度分析 | 方法 | 时间复杂度 | 空间复杂度 | 特点 | |---------|------------|------------|--------------------------| | 递归法 | $O(n)$ | $O(n)$ | 代码简洁，可能栈溢出[^1] | | 迭代法 | $O(n)$ | $O(n)$ | 显式控制栈空间[^1] | ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值