DS二叉树--二叉树之最大路径

题目描述

给定一颗二叉树的逻辑结构（先序遍历的结果，空树用字符‘0’表示，例如AB0C00D00），建立该二叉树的二叉链式存储结构。二叉树的每个结点都有一个权值，从根结点到每个叶子结点将形成一条路径。

每条路径的权值等于路径上所有结点的权值和。编程求出二叉树的最大路径权值。 如下图所示，共有4个叶子即有4条路径，
路径1权值=5 + 4 + 11 + 7 = 27
路径2权值=5 + 4 + 11 + 2 = 22
路径3权值=5 + 8 + 13 = 26
路径4权值=5 + 8 + 4 + 1 = 18
可计算出最大路径权值是27。

该树输入的先序遍历结果为ABCD00E000FG00H0I00，各结点权值为：
A-5，B-4，C-11，D-7，E-2，F-8，G-13，H-4，I-1

输入

第一行输入一个整数t，表示有t个测试数据
第二行输入一棵二叉树的先序遍历，每个结点用字母表示
第三行先输入n表示二叉树的结点数量，然后输入每个结点的权值，权值顺序与前面结点输入顺序对应 以此类推输入下一棵二叉树

输出

每行输出每棵二叉树的最大路径权值，如果最大路径权值有重复，只输出1个

样例输入

2
AB0C00D00
4 5 3 2 6
ABCD00E000FG00H0I00
9 5 4 11 7 2 8 13 4 1

样例输出

11
27

#include <iostream>
#include <queue>
using namespace std;

class Binary_tree_node
{
public:
    char data;                                //数据域
    int weight;                               //结点权重
    Binary_tree_node *LeftChild, *RightChild; //左右孩子
    Binary_tree_node() : LeftChild(NULL), RightChild(NULL) {}
    ~Binary_tree_node()
    {
        delete LeftChild;
        delete RightChild;
    }
};

class Binary_tree
{
public:
    Binary_tree_node *root; //根节点
    queue<int> weights;     //
    int maxRoad;            //最大权重
    Binary_tree() {}
    ~Binary_tree() {}
    //先序创建二叉树
    void CreateTree()
    {
        CreateTree(root);
    }
    void CreateTree(Binary_tree_node *&p)
    {
        char ch;
        cin >> ch;
        if (ch == '0') //结点为空
        {
            p = NULL;
        }
        else //结点不为空
        {
            p = new Binary_tree_node;
            p->data = ch;
            CreateTree(p->LeftChild);
            CreateTree(p->RightChild);
        }
    }
    //获取最大路径权值
    void getRoad()
    {
        int nodes_num;
        cin>>nodes_num;
        while(nodes_num--)
        {
            int num;
            cin>>num;
            weights.push(num);
        }
        getRoad(root,0);
        cout<<maxRoad<<endl;
    }
    void getRoad(Binary_tree_node *p, int road)
    {
        if (p != NULL)              //结点不为空
        {
            p->weight=weights.front()+road;
            weights.pop();
            getRoad(p->LeftChild,p->weight);
            getRoad(p->RightChild,p->weight);
            
            if(!p->LeftChild&&!p->RightChild)
            {
                if(p->weight>maxRoad)
                {
                    maxRoad=p->weight;
                }
            }
        }
    }
};

int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        Binary_tree Bt;
        Bt.CreateTree();
        Bt.getRoad();
    }
    return 0;
}