1 题目

2 思路

题目的大意就是求树根节点到叶子结点的路径，然后根据路径上的权值求出每条路径的值，最后累加得到所有路径的值。

求路径，使用先序遍历，每次记录遍历到的每层节点，当该节点的左右孩子均为空时，该节点为叶子节点，计算路径值。

3 代码

• 1,depth方法中，每次value值，都逐层累加计算路径值。
• 2,depth2方法2中，每次记录路径值，当遇到叶节点时，计算路径值。

class Solution {
public:
    int res = 0;
    void depth(TreeNode* root, int value){
        if(root != nullptr){
            value = (value<<1) + root->val;//结点值每到下一层就进一位
//        cout<<value<<" ";
            if(root->left == nullptr && root->right == nullptr){
                res += value;
                return;
            }
            depth(root->left, value);
            depth(root->right, value);
        }
    }


    void depth2(TreeNode* root, vector<int> path,  int deep){
        if(root == nullptr) return;
        path[deep] = root->val;
        if(root->left == nullptr && root->right == nullptr){
            for(int d = 0;d <= deep;d++){
                res += path[d] * pow(2, deep - d);
            }

            //打印路径
//            for (int d = 0; d <= deep; d++)
//            {
//                if(d == 0) printf("%d", path[d]);
//                else printf("->%d", path[d]);
//            }
//            printf("\n");

            return;
        }
        depth2(root->left, path,  deep + 1);
        depth2(root->right, path, deep + 1);
    }


    int sumRootToLeaf(TreeNode* root) {
        //法1
        depth(root, 0);
        //法2
//        vector<int> path(100, 0);
//        depth2(root, path, 0);

        return res;
    }
};

4 测试用例

测试输出：

//输出
1,0,1,0,1,0,1
//输出
1->0->0
1->0->1
1->1->0
1->1->1
22

//输入
1,1
//输出
1->1
3

测试代码：

#include <iostream>

#include <vector>
#include <stack>
#include <cmath>
#include <deque>

using namespace std;

//树结构
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) {}
};

//层序遍历创树
void createBiTNode(TreeNode** treeNode, deque<int> dataDeq) {//层序遍历建立二叉树
    //空结点值
    int nullTreeNodeValue = -1;

    //cout<<dataDeq.size()<<endl;
    for(size_t i = 1; ; i++){
        int fullBinaryTreeNum = pow(2, i) - 1;
        if(dataDeq.size() <= fullBinaryTreeNum){
            while(dataDeq.size() < fullBinaryTreeNum){
                dataDeq.push_back(nullTreeNodeValue);//添加空节点凑成一棵树
            }
            break;
        }
    }

//    for(auto i:dataDeq){
//        cout<<i<<" ";
//    }cout<<endl;

    //特殊处理根结点
    char data;
    data = dataDeq.front();
    dataDeq.pop_front();
    TreeNode * node = new TreeNode();
    *treeNode = node;
    (*treeNode)->val = data;

    deque<TreeNode**> nodeDeq;//用于层序建立树时访问双亲节点
    nodeDeq.push_back(treeNode);

    int index = 2;//用于判定左右孩子（左偶，右奇）
    while (!dataDeq.empty()){//当数据节点非空时，进行建树

        TreeNode** nodeParent = nodeDeq.front();
        nodeDeq.pop_front();

        for(int i = 0; i < 2;i++){
            data = dataDeq.front();
            dataDeq.pop_front();
            if(data == nullTreeNodeValue){
                if(index%2 == 0) (*nodeParent)->left = nullptr;
                else (*nodeParent)->right = nullptr;
            }else{
                TreeNode * node = new TreeNode();
                node->val = data;
                if(index%2 == 0){
                    (*nodeParent)->left = node;
                    nodeDeq.push_back(&(*nodeParent)->left);
                }else{
                    (*nodeParent)->right = node;
                    nodeDeq.push_back(&(*nodeParent)->right);
                }
            }
            index++;
        }
    }
}


class Solution {
public:
    int res = 0;
    void depth(TreeNode* root, int value){
        if(root != nullptr){
            value = (value<<1) + root->val;//结点值每到下一层就进一位
//        cout<<value<<" ";
            if(root->left == nullptr && root->right == nullptr){
                res += value;
                return;
            }
            depth(root->left, value);
            depth(root->right, value);
        }
    }


    void depth2(TreeNode* root, vector<int> path,  int deep){
        if(root == nullptr) return;
        path[deep] = root->val;
        if(root->left == nullptr && root->right == nullptr){
            for(int d = 0;d <= deep;d++){
                res += path[d] * pow(2, deep - d);
            }

            //打印路径
//            for (int d = 0; d <= deep; d++)
//            {
//                if(d == 0) printf("%d", path[d]);
//                else printf("->%d", path[d]);
//            }
//            printf("\n");

            return;
        }
        depth2(root->left, path,  deep + 1);
        depth2(root->right, path, deep + 1);
    }


    int sumRootToLeaf(TreeNode* root) {
        //法1
        depth(root, 0);
        //法2
//        vector<int> path(100, 0);
//        depth2(root, path, 0);

        return res;
    }
};


int main() {
    deque<int> treeVec{1,0,1,0,1,0,1};
//    deque<int> treeVec{1,1};

    TreeNode* tree = new TreeNode();
    createBiTNode(&tree, treeVec);
    Solution s;
    cout<<s.sumRootToLeaf(tree);

    return 0;
}