Leetcode 129. Sum Root to Leaf Numbers

最新推荐文章于 2025-09-13 14:08:34 发布

ruihuank

最新推荐文章于 2025-09-13 14:08:34 发布

阅读量100

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode 笔记文章标签： leetcode

本文链接：https://blog.youkuaiyun.com/ruihuank/article/details/79313562

leetcode 笔记专栏收录该内容

127 篇文章

订阅专栏

本文介绍了一种解决二叉树节点路径数值求和的方法，通过三种不同的实现方式：使用双端队列、递归函数及栈结构，来计算从根节点到叶节点的所有路径数字的总和。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int sumNumbers(TreeNode* root) {
        if (root == nullptr) return 0;
        deque<TreeNode*> nodes;
        nodes.emplace_back(root);
        deque<int> vals;
        vals.emplace_back(root->val);

        int sum;

        while (!nodes.empty()) {
            int n = nodes.size();
            for (int i = 0; i != n; ++i) {
                TreeNode* node = nodes.front();
                int val = vals.front();
                if (node->left != nullptr) {
                    nodes.emplace_back(node->left);
                    vals.emplace_back(val*10 + node->left->val);
                }
                if (node->right != nullptr) {
                    nodes.emplace_back(node->right);
                    vals.emplace_back(val*10 + node->right->val);
                }

                nodes.pop_front();
                vals.pop_front();
                if (node->right == nullptr && node->left == nullptr)
                    sum += val;
            }
        }
        return sum;
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val; 
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int sumNumbers(TreeNode* root) {
        if (root == nullptr) return 0;
        int sum = 0;
        reSolver(root, 0, sum);
        return sum;
    }

private:
    void reSolver(TreeNode* root, int ans, int& sum) {
        ans += root->val;
        if (root->left != nullptr) 
            reSolver(root->left, ans * 10, sum);
        if (root->right != nullptr)
            reSolver(root->right, ans * 10, sum);
        if (root->right == nullptr && root->left == nullptr) 
            sum += ans;

    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int sumNumbers(TreeNode* root) {

        if (root == nullptr) return 0;

        using TUPLE = tuple<TreeNode*, int>;
        stack<TUPLE> s;
        int sum = 0;
        int topVal = 0;

        TreeNode* node = root;
        while (!s.empty() || node != nullptr) {

            if (node == nullptr) {
                auto t = s.top();
                node = get<0>(t);
                topVal = get<1>(t);
                s.pop();
                if (node->left == nullptr && node->right == nullptr) 
                    sum += topVal;
                node = node->right;
            } else {
                topVal = topVal * 10 + node->val;
                s.push(TUPLE(node, topVal));
                node = node->left;
            }
        }

        return sum;
    }
};