力扣第129题：求根到叶子节点数字之和

本文链接：https://blog.youkuaiyun.com/weixin_48941116/article/details/144873798

力扣第129题：求根到叶子节点数字之和 - C语言解法

题目描述

给定一个二叉树，求根到叶子节点的数字之和。

每条从根到叶子的路径都代表一个数字。例如，根到叶子路径 1->2->3 代表数字 123。返回所有路径数字之和。

示例 1：

输入：root = [1,2,3]
输出：25
解释：
    1
   / \
  2   3
根到叶子的数字是 12 和 13，数字之和是 12 + 13 = 25。

示例 2：

输入：root = [4,9,0,5,1]
输出：1026
解释：
    4
   / \
  9   0
 / \
5   1
根到叶子的数字是 495 和 491，以及 40。数字之和是 495 + 491 + 40 = 1026。

示例 3：

输入：root = [0]
输出：0

解题思路

本题的目标是求从根到每一个叶子节点路径上形成的数字之和。通过 深度优先搜索（DFS） 遍历树的每一条路径，并计算路径数字的和。

1. 深度优先搜索（DFS）

我们从根节点开始，沿着每一条路径向下递归。每次遍历时，我们可以通过将当前节点的值加到当前路径数字中来构造路径数字。对于每个叶子节点，我们将当前路径数字加到最终的结果中。

步骤：

使用 DFS 遍历二叉树，每次递归时将当前节点的值加到当前路径的数字上。
如果遇到叶子节点，说明一条完整的路径已经形成，将其数值加到总和中。
返回总和。

2. 时间复杂度和空间复杂度

时间复杂度： $O (n)$ ，其中 $n$ 是二叉树的节点个数。我们访问每个节点一次。
空间复杂度： $O (h)$ ，其中 $h$ 是二叉树的高度，递归栈的深度与树的高度相关。

C语言代码实现

#include <stdio.h>
#include <stdlib.h>

// 定义二叉树节点结构
struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

// 创建节点函数
struct TreeNode* createNode(int val) {
    struct TreeNode* newNode = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    newNode->val = val;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 深度优先搜索（DFS）递归函数
void dfs(struct TreeNode* root, int currentSum, int* totalSum) {
    if (root == NULL) {
        return;
    }

    // 更新当前路径数字
    currentSum = currentSum * 10 + root->val;

    // 如果是叶子节点，累加当前路径的数字
    if (root->left == NULL && root->right == NULL) {
        *totalSum += currentSum;
    }

    // 递归左子树和右子树
    dfs(root->left, currentSum, totalSum);
    dfs(root->right, currentSum, totalSum);
}

// 主函数，求根到叶子节点数字之和
int sumNumbers(struct TreeNode* root) {
    int totalSum = 0;
    dfs(root, 0, &totalSum);
    return totalSum;
}

int main() {
    // 示例1：创建二叉树 [1,2,3]
    struct TreeNode* root1 = createNode(1);
    root1->left = createNode(2);
    root1->right = createNode(3);
    
    printf("根到叶子节点数字之和：%d\n", sumNumbers(root1)); // 输出：25

    // 示例2：创建二叉树 [4,9,0,5,1]
    struct TreeNode* root2 = createNode(4);
    root2->left = createNode(9);
    root2->right = createNode(0);
    root2->left->left = createNode(5);
    root2->left->right = createNode(1);
    
    printf("根到叶子节点数字之和：%d\n", sumNumbers(root2)); // 输出：1026

    // 示例3：创建二叉树 [0]
    struct TreeNode* root3 = createNode(0);
    
    printf("根到叶子节点数字之和：%d\n", sumNumbers(root3)); // 输出：0

    return 0;
}

代码解析

1. `dfs` 函数

void dfs(struct TreeNode* root, int currentSum, int* totalSum) {
    if (root == NULL) {
        return;
    }

    // 更新当前路径数字
    currentSum = currentSum * 10 + root->val;

    // 如果是叶子节点，累加当前路径的数字
    if (root->left == NULL && root->right == NULL) {
        *totalSum += currentSum;
    }

    // 递归左子树和右子树
    dfs(root->left, currentSum, totalSum);
    dfs(root->right, currentSum, totalSum);
}

参数解释：
- root：当前节点。
- currentSum：当前路径上的数字。
- totalSum：最终的总和。
递归过程：
- 如果当前节点为空，直接返回。
- 将当前节点的值加入 currentSum，并更新路径数字。
- 如果当前节点是叶子节点，将 currentSum 加入 totalSum。
- 递归遍历左子树和右子树。

2. `sumNumbers` 函数

int sumNumbers(struct TreeNode* root) {
    int totalSum = 0;
    dfs(root, 0, &totalSum);
    return totalSum;
}

该函数初始化总和 totalSum 为 0，调用 dfs 函数进行深度优先搜索，最终返回计算出的总和。

3. `main` 函数

int main() {
    // 示例1：创建二叉树 [1,2,3]
    struct TreeNode* root1 = createNode(1);
    root1->left = createNode(2);
    root1->right = createNode(3);
    
    printf("根到叶子节点数字之和：%d\n", sumNumbers(root1)); // 输出：25

    // 示例2：创建二叉树 [4,9,0,5,1]
    struct TreeNode* root2 = createNode(4);
    root2->left = createNode(9);
    root2->right = createNode(0);
    root2->left->left = createNode(5);
    root2->left->right = createNode(1);
    
    printf("根到叶子节点数字之和：%d\n", sumNumbers(root2)); // 输出：1026

    // 示例3：创建二叉树 [0]
    struct TreeNode* root3 = createNode(0);
    
    printf("根到叶子节点数字之和：%d\n", sumNumbers(root3)); // 输出：0

    return 0;
}