算法训练营打卡Day16

最新推荐文章于 2024-09-28 22:05:59 发布

idris的算法日记

最新推荐文章于 2024-09-28 22:05:59 发布

阅读量151

点赞数 3

文章标签：算法 c语言 python 数据结构

本文链接：https://blog.csdn.net/Zoe_igxgx/article/details/142578888

版权

找树左下角的值
路径之和

题目1、513.找树左下角的值

力扣题目链接(opens new window)

怎么找二叉树的左下角？递归中又带回溯了，怎么办？| LeetCode：513.找二叉树左下角的值_哔哩哔哩_bilibili

给定一个二叉树，在树的最后一行找到最左边的值。

示例 1:

513.找树左下角的值

C（仅供参考）

貌似力扣里面写结构体会报错？麻了

#include <stdio.h>  
// Definition for a binary tree node.  
struct TreeNode {  
    int val;  
    struct TreeNode *left;  
    struct TreeNode *right;  
};  
  
int maxDepth = -1;  
int res = -1; // 假设树中不会包含值为-1的节点  
  
void getVal(struct TreeNode* root, int depth) {  
    if (root == NULL) {  
        return;  
    }  
    // 找到叶子节点  
    if (root->left == NULL && root->right == NULL) {  
        if (maxDepth < depth) {  
            maxDepth = depth;  
            res = root->val;  
        }  
        return;  
    }  
    if (root->left != NULL) {  
        getVal(root->left, depth + 1);  
    }  
    if (root->right != NULL) {  
        getVal(root->right, depth + 1);  
    }  
}  
  
int findBottomLeftValue(struct TreeNode* root) {  
    getVal(root, 0);  
    return res;  
}

C#（代码随想录）

//递归
int maxDepth = -1;
int res = 0;
public int FindBottomLeftValue(TreeNode root)
{
    Traversal(root, 0);
    return res;
}
public void Traversal(TreeNode root, int depth)
{
    if (root.left == null && root.right == null)
    {
        if (depth > maxDepth)
        {
            maxDepth = depth;
            res = root.val;
        }
        return;
    }
    if (root.left != null)
    {
        Traversal(root.left, depth + 1);
    }
    if (root.right != null)
    {
        Traversal(root.right, depth + 1);
    }
    return;
}

题目2、112. 路径总和

力扣题目链接(opens new window)

拿不准的遍历顺序，搞不清的回溯过程，我太难了！ | LeetCode：112. 路径总和_哔哩哔哩_bilibili

给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。

说明: 叶子节点是指没有子节点的节点。

示例: 给定如下二叉树，以及目标和 sum = 22，

返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4->11->2。

python

class Solution:
    def traversal(self, cur, count):
        if not cur.left and not cur.right and count == 0: # 遇到叶子节点，并且计数为0
            return True
        if not cur.left and not cur.right: # 遇到叶子节点直接返回
            return False
        
        if cur.left: # 左
            count -= cur.left.val
            if self.traversal(cur.left, count): # 递归，处理节点
                return True
            count += cur.left.val # 回溯，撤销处理结果
            
        if cur.right: # 右
            count -= cur.right.val
            if self.traversal(cur.right, count): # 递归，处理节点
                return True
            count += cur.right.val # 回溯，撤销处理结果
            
        return False
    
    def hasPathSum(self, root, sum):
        if root is None:
            return False
        return self.traversal(root, sum - root.val)

C（已通过，放心食用）

bool Traversal(struct TreeNode* root, int targetSum) {  
    // 如果节点为空，则直接返回false  
    if (root == NULL) {  
        return false;  
    }  
      
    // 如果当前节点是叶子节点且目标和为0，则返回true  
    if (root->left == NULL && root->right == NULL && targetSum == root->val) {  
        return true;  
    }  
      
    // 递归检查左子树  
    if (root->left != NULL && Traversal(root->left, targetSum - root->val)) {  
        return true;  
    }  
      
    // 递归检查右子树  
    if (root->right != NULL && Traversal(root->right, targetSum - root->val)) {  
        return true;  
    }  
      
    // 如果左子树和右子树都没有找到满足条件的路径，则返回false  
    return false;  
}  
bool hasPathSum(struct TreeNode* root, int targetSum) {  
    if (root == NULL) {  
        return false;  
    }  
    return Traversal(root, targetSum);  
}

题目3会在国庆补充~~~什么？国庆！没错，等我放假了，没做的题目你们得完蛋！~~

总结：我们的递归函数什么时候需要返回值呢？简单来说，可以根据是否需要遍历整棵二叉树，是否需要对递归函数返回值进行处理来判断~