面试经典算法系列之二叉树9 -- 二叉树求根节点到叶子结点数字之和

于 2024-04-18 23:42:26 发布
阅读量485 收藏 11
点赞数 3
分类专栏： 面试经典算法系列 文章标签： 面试 算法 职场和发展 leetcode c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44630255/article/details/137942055
版权

面试经典算法24 - 二叉树求根节点到叶子结点数字之和

LeetCode.129
公众号：阿Q技术站

问题描述

给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。

每条从根节点到叶节点的路径都代表一个数字：

例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。

计算从根节点到叶节点生成的 所有数字之和 。

叶节点 是指没有子节点的节点。

示例 1：

输入：root = [1,2,3]
输出：25
解释：
从根到叶子节点路径 1->2 代表数字 12
从根到叶子节点路径 1->3 代表数字 13
因此，数字总和 = 12 + 13 = 25

示例 2：

输入：root = [4,9,0,5,1]
输出：1026
解释：
从根到叶子节点路径 4->9->5 代表数字 495
从根到叶子节点路径 4->9->1 代表数字 491
从根到叶子节点路径 4->0 代表数字 40
因此，数字总和 = 495 + 491 + 40 = 1026

提示：

  • 树中节点的数目在范围 [1, 1000] 内
  • 0 <= Node.val <= 9
  • 树的深度不超过 10

思路

递归
  1. 使用深度优先搜索（DFS）遍历二叉树，遍历过程中记录从根节点到当前节点的路径数字；
  2. 当遍历到叶节点时，将当前路径数字加到总和中；
  3. 遍历完成后，返回总和即可。
非递归
  1. 使用两个栈 nodeStack 和 numStack 分别存储节点和对应的路径数字。
  2. 将根节点入栈 nodeStack 和 numStack。
  3. 循环执行以下步骤直到 nodeStack 为空：
    • 弹出栈顶节点 node 和对应的路径数字 num。
    • 如果 node 是叶节点，则将 num 加到总和中。
    • 如果 node 不是叶节点，则将 node 的子节点和对应的路径数字入栈。
  4. 返回总和。

图解

  1. 申请两个栈nodeStack和numStack分别存放节点和对应的路径数字（这里为了看起来直观，就将节点也将节点数字表示）。将根节点入栈。

  1. 如果存储节点的栈不为空，就将栈顶节点和栈顶路径数字弹出。

  1. 先将右子节点入栈，再将左子结点入栈。并将对应的值入栈。

  1. 将栈顶元素弹出。

    • 先将左子节点弹出

    • 再将右子节点弹出

  2. 左子结点非叶子结点，就继续将其右左节点依次入栈。右子节点是叶子结点。所以就将路径数字加到总和中。

image-20240312000041838

  1. 重复5、6步。但是这两个节点都是叶子结点，所以就将其加到总和中。

参考代码

C++
递归
#include <iostream>
#include <vector>

using namespace std;

// 二叉树节点的定义
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

int sumNumbers(TreeNode* root) {
    if (!root) return 0; // 如果根节点为空，直接返回0

    int totalSum = 0; // 总和
    vector<int> path; // 当前路径

    // 深度优先搜索函数
    function<void(TreeNode*)> dfs = [&](TreeNode* node) {
        if (!node) return; // 如果节点为空，直接返回
        path.push_back(node->val); // 将当前节点值加入路径
        if (!node->left && !node->right) { // 如果是叶节点
            int pathNum = 0;
            for (int num : path) {
                pathNum = pathNum * 10 + num; // 计算路径数字
            }
            totalSum += pathNum; // 将路径数字加到总和中
        } else {
            dfs(node->left); // 递归处理左子节点
            dfs(node->right); // 递归处理右子节点
        }
        path.pop_back(); // 回溯，移除当前节点值
    };

    dfs(root); // 从根节点开始深度优先搜索

    return totalSum; // 返回总和
}

// 创建二叉树
TreeNode* createTree(vector<int>& nodes, int index) {
    if (index >= nodes.size() || nodes[index] == -1) {
        return nullptr; // 如果节点为空，则返回nullptr
    }
    TreeNode* root = new TreeNode(nodes[index]); // 创建当前节点
    root->left = createTree(nodes, 2 * index + 1); // 创建左子树
    root->right = createTree(nodes, 2 * index + 2); // 创建右子树
    return root; // 返回当前节点
}

// 销毁二叉树
void destroyTree(TreeNode* root) {
    if (!root) return; // 如果根节点为空，直接返回
    destroyTree(root->left); // 递归销毁左子树
    destroyTree(root->right); // 递归销毁右子树
    delete root; // 删除当前节点
}

int main() {
    vector<int> nodes = {1, 2, 3}; // 二叉树的先序遍历序列
    TreeNode* root = createTree(nodes, 0); // 创建二叉树
    int result = sumNumbers(root); // 计算所有路径数字之和
    cout << result << endl; // 输出结果

    destroyTree(root); // 销毁二叉树

    return 0;
}
非递归
#include <iostream>
#include <vector>
#include <stack>

using namespace std;

// 二叉树节点的定义
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

int sumNumbers(TreeNode* root) {
    if (!root) return 0; // 如果根节点为空，直接返回0

    int totalSum = 0; // 总和
    stack<TreeNode*> nodeStack; // 存储节点的栈
    stack<int> numStack; // 存储路径数字的栈
    nodeStack.push(root); // 将根节点入栈
    numStack.push(root->val); // 将根节点的值加入路径数字栈

    while (!nodeStack.empty()) {
        TreeNode* node = nodeStack.top(); // 获取栈顶节点
        nodeStack.pop(); // 弹出栈顶节点
        int num = numStack.top(); // 获取栈顶路径数字
        numStack.pop(); // 弹出栈顶路径数字

        if (!node->left && !node->right) { // 如果是叶节点
            totalSum += num; // 将路径数字加到总和中
        } else {
            if (node->right) { // 如果有右子节点，入栈右子节点和对应的路径数字
                nodeStack.push(node->right);
                numStack.push(num * 10 + node->right->val);
            }
            if (node->left) { // 如果有左子节点，入栈左子节点和对应的路径数字
                nodeStack.push(node->left);
                numStack.push(num * 10 + node->left->val);
            }
        }
    }

    return totalSum; // 返回总和
}

// 创建二叉树
TreeNode* createTree(vector<int>& nodes, int index) {
    if (index >= nodes.size() || nodes[index] == -1) {
        return nullptr; // 如果节点为空，则返回nullptr
    }
    TreeNode* root = new TreeNode(nodes[index]); // 创建当前节点
    root->left = createTree(nodes, 2 * index + 1); // 创建左子树
    root->right = createTree(nodes, 2 * index + 2); // 创建右子树
    return root; // 返回当前节点
}

// 销毁二叉树
void destroyTree(TreeNode* root) {
    if (!root) return; // 如果根节点为空，直接返回
    destroyTree(root->left); // 递归销毁左子树
    destroyTree(root->right); // 递归销毁右子树
    delete root; // 删除当前节点
}

int main() {
    vector<int> nodes = {1, 2, 3}; // 二叉树的先序遍历序列
    TreeNode* root = createTree(nodes, 0); // 创建二叉树
    int result = sumNumbers(root); // 计算所有路径数字之和
    cout << result << endl; // 输出结果

    destroyTree(root); // 销毁二叉树

    return 0;
}
Java
import java.util.*;

// 定义二叉树节点
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

public class Solution {
    public int sumNumbers(TreeNode root) {
        if (root == null) return 0;

        int totalSum = 0;
        Stack<TreeNode> nodeStack = new Stack<>(); // 用于存储节点的栈
        Stack<Integer> numStack = new Stack<>(); // 用于存储路径数字的栈
        nodeStack.push(root);
        numStack.push(root.val);

        while (!nodeStack.isEmpty()) {
            TreeNode node = nodeStack.pop();
            int num = numStack.pop();

            if (node.left == null && node.right == null) {
                totalSum += num; // 如果是叶节点，将路径数字加到总和中
            } else {
                if (node.right != null) {
                    nodeStack.push(node.right);
                    numStack.push(num * 10 + node.right.val); // 将右子节点和路径数字入栈
                }
                if (node.left != null) {
                    nodeStack.push(node.left);
                    numStack.push(num * 10 + node.left.val); // 将左子节点和路径数字入栈
                }
            }
        }

        return totalSum; // 返回总和
    }

    // 创建二叉树
    public TreeNode createTree(Integer[] nodes, int index) {
        if (index >= nodes.length || nodes[index] == null) {
            return null;
        }
        TreeNode root = new TreeNode(nodes[index]);
        root.left = createTree(nodes, 2 * index + 1);
        root.right = createTree(nodes, 2 * index + 2);
        return root;
    }

    // 测试
    public static void main(String[] args) {
        Solution solution = new Solution();
        Integer[] nodes = {1, 2, 3};
        TreeNode root = solution.createTree(nodes, 0);
        int result = solution.sumNumbers(root);
        System.out.println(result);
    }
}
Python
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def sumNumbers(root):
    if not root:
        return 0

    total_sum = 0
    node_stack = [root]  # 用于存储节点的栈
    num_stack = [root.val]  # 用于存储路径数字的栈

    while node_stack:
        node = node_stack.pop()
        num = num_stack.pop()

        if not node.left and not node.right:
            total_sum += num  # 如果是叶节点，将路径数字加到总和中
        else:
            if node.right:
                node_stack.append(node.right)
                num_stack.append(num * 10 + node.right.val)  # 将右子节点和路径数字入栈
            if node.left:
                node_stack.append(node.left)
                num_stack.append(num * 10 + node.left.val)  # 将左子节点和路径数字入栈

    return total_sum  # 返回总和

# 创建二叉树
def create_tree(nodes, index):
    if index >= len(nodes) or nodes[index] is None:
        return None
    root = TreeNode(nodes[index])
    root.left = create_tree(nodes, 2 * index + 1)
    root.right = create_tree(nodes, 2 * index + 2)
    return root

# 测试
nodes = [1, 2, 3]
root = create_tree(nodes, 0)
result = sumNumbers(root)
print(result)
阿Q技术站
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
简：二叉树分支求和
Yubochang的博客
09-09 758
题目描述 给定一个二叉树和一个值\ sumsum，判断是否有从根节点到叶子节点的节点值之和等于\ sumsum的路径， 例如： 给出如下的二叉树，\ sum=22sum=22， 返回true，因为存在一条路径5\to 4\to 11\to 25→4→11→2的节点值之和为 22 解： 这道题主要考察二叉树的深度遍历，这道题要避免多余的查找，一旦找到符合的就直接返回结束递归。 import java.util.*; /* * public class TreeNode { * i...
PTA 6-1 二叉树度为2的结点求和
June0611的博客
06-20 1702
6-1 二叉树度为2的结点求和 (16 分) 实现一个函数，返回二叉树bt中度为2的结点的数值之和。 函数接口定义： int sumDCNodes(struct BinTree *bt); 其中二叉树定义如下： struct BinTree{ int data; struct BinTree *left; struct BinTree *right; }; 题目保证二叉树中所有元素均为整数且各元素之和在整型范围内。 裁判测试程序样例： #include "std
算法 - 二叉树根节点到叶子节点的所有路径和
是非的Android学习之路
03-30 1928
每天一道算法题（2021年3月30日）《二叉树根节点到叶子节点所有路径和 - 中等难度》
【数据结构-二叉树 八】【遍历求和】：求根到叶子节点数字之和
最新发布
MaoLin Tian's Blog
10-08 650
废话不多说，喊一句号子鼓励自己：程序员永不失业，程序员走向架构！本篇Blog的主题是【遍历求和】，使用【二叉树】这个基本的数据结构来实现，这个高频题的站点是：CodeTop，筛选条件为：目标公司+最近一年+出现频率排序，由高到低的去牛客TOP101去找，只有两个地方都出现过才做这道题（CodeTop本身汇聚了LeetCode的来源），确保刷的题都是高频要面试考的题。 明确目标题后，附上题目链接，后期可以依据解题思路反复快速练习，题目按照题干的基本数据结构分类，且每个分类的第一篇必定是对基础数据结构的介绍。D
遍历二叉树:对二叉树的所有节点求和的两种方法(2)
qq_35299223的博客
09-07 6047
方法1，类似于求二叉树的高度,有返回值 int Sum(TreeNode* T){ if(T==NULL)return 0; int sum=0; int lsum,rsum; lsum=Sum(T->left); rsum=Sum(T->right); sum=T->val+lsum...
【二叉树】二叉树路径求和
_von Neumann
07-08 2349
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
js代码-（算法）（二叉树）到叶子节点和等于n
07-16
本文将深入探讨如何通过JS代码解决一个特定的二叉树问题：找到所有从根节点到叶子节点的路径，其路径上的节点值之和等于给定的目标值`n`。 首先，我们需要理解二叉树的基本概念。二叉树每个节点包含一个值，一个左...
C++使用递归和非递归算法实现的二叉树叶子节点个数计算方法
08-30
C++使用递归和非递归算法实现的二叉树叶子节点个数计算方法 本文主要介绍了C++使用递归和非递归算法实现的二叉树叶子节点个数计算方法，涉及C++二叉树的定义、遍历、统计相关操作技巧。 一、二叉树的定义 在...
c代码-求二叉树的叶子节点和高度
07-16
二叉树的高度是从根节点到最远叶子节点的最长路径上的边数。同样，我们可以使用递归来计算高度。定义一个函数`height`，接受一个节点指针作为参数，返回该节点子树的高度： ```c int height(Node* root) { if ...
JavaScript数据结构和算法之二叉树详解
11-30
在二叉树中，每个节点最多有两个子节点，即左子节点和右子节点，这使得二叉树成为处理二选一问题的理想模型。节点之间通过指针相连，形成父子关系。在JavaScript中，二叉树节点通常被定义为包含值、指向左子节点和右...
递归算法实现二叉树的各种运算
04-21
C++自己写的二叉树的各种运算 希望对大家有帮助 内有二叉树各种常用的函数，前续，中序，后续以及层次遍历。删除 叶子节点数 复制 交换左右子树 4_20为主函数是对上述运算的实现
【Leetcode】1038. Binary Search Tree to Greater Sum Tree（二叉树求和）
小I的博客
05-05 927
Given the root of a binarysearchtree with distinct values, modify it so that everynodehas a new value equal to the sum of the values of the original tree that are greater than or equal tonode.val...
二叉树最深层次元素求和(基于层序遍历算法)
weixin_42048463的博客
06-13 291
#include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 #define Yes 1 #define No 0 typedef short ElemType; typedef short Status; struct BiTreeNode/* 二叉树结点定义 */ { ElemType data; struct BiTreeNode *LChild;/* 左孩子指针 */ str...
求二叉树的路径和
gcs的博客
07-01 942
给定一个二叉树，找出所有路径中各节点相加总和。 一个有效的路径，指的是从根节点到叶节点的路径。这样就是一条有效的路径,求这个路径上值的和,已经对应路径上的值. 二叉树的节点定义, 根据传入数组,生成对应的完全二叉树 @interface TreeNode : NSObject /// 根据数组生成一个完全二叉树 + (TreeNode *)nodeWithDataArray:(NSArray *)dataArray; /// 生成一个节点,左右节点为nil + (TreeNo...
leetcode之二叉树遍历求和巧妙递归
ONE_PIECE的专栏
09-13 2560
和之前那个题一样，递归写的不够巧妙,这里巧妙用了和减值： 贴上自己的： class Solution { public: bool hasPathSum(TreeNode *root, int sum) { if(!root) return false; bool result=false; dfs(root,0,
Path Sum II 二叉树求和
小人物的草稿本
04-28 771
Path Sum II   Given a binary tree and a sum, find all root-to-leaf paths where each path's sum equals the given sum. For example: Given the below binary tree and sum = 22, 5
二叉树的路径总和
Tmvller的博客
07-12 159
求二叉树的路径总和，考虑用递归，从当前节点 root 到叶子节点的路径，满足其路径和为 sum。假定从根节点到当前节点的值之和为 val，我们可以将这个大问题转化为一个小问题：是否存在从当前节点的子节点到叶子的路径，满足其路径和为 sum - val。若当前节点就是叶子节点，那么我们直接判断 sum 是否等于 val 即可（因为路径和已经确定，就是当前节点的值，我们只需要判断该路径和是否满足条件）。函数会遍历二叉树中的所有路径，并检查路径上的节点值之和是否等于目标和。
二叉树路径总和
Clement
06-11 192
给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。 说明: 叶子节点是指没有子节点的节点。 示例: 给定如下二叉树，以及目标和 sum = 22， 5 / \ 4 8 / / \ 11 13 4 / \ \ 7 2 1 返回 true, 因为存在目标和为 22 的根节点到叶子节点的路径 5->4-&gt
LintCode 二叉树路径求和
u010864884的博客
11-28 438
//AC 的答案/** * Definition of TreeNode: * class TreeNode { * public: * int val; * TreeNode *left, *right; * TreeNode(int val) { * this->val = val; * this->left = this
用递归算法返回二叉树返回从根节点到叶子结点的路径
03-28
以下是Python代码实现: ```python class TreeNode: def __init__(self, value): self.val = value self.left = None self.right = None def binary_tree_paths(root): if not root: return [] if not root.left and not root.right: return [str(root.val)] left_paths = binary_tree_paths(root.left) right_paths = binary_tree_paths(root.right) paths = [] for path in left_paths + right_paths: paths.append(str(root.val) + "->" + path) return paths ``` 使用方法： ```python root = TreeNode(1) root.left = TreeNode(2) root.right = TreeNode(3) root.left.right = TreeNode(5) print(binary_tree_paths(root)) # ["1->2->5", "1->3"] ``` 该函数首先检查根节点是否存在，如果不存在，返回空列表。然后，如果根节点没有左右子节点，返回一个包含根节点值的列表。否则，递归地计算左右子树的路径，将它们与根节点值组合起来，形成完整的路径列表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值