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个

#include<iostream>
#include<string>
usingnamespace std;
class BitreeNode
{
public:
    char data;
    int weight;
    BitreeNode *left;
    BitreeNode *right;
    BitreeNode()
    {
        weight=0;
        left=right=NULL;
    }
};
 
class Bitree
{
public:
    BitreeNode *Root;
    int pos,index;///pos控制字符，index控制权值int maxpath;
    string strtree;
    Bitree(int *w,string str)
    {
        pos=index=0;
        maxpath=0;
        strtree=str;
        Root=CreateBitree(w,0);
    };
    BitreeNode *CreateBitree(int *w,int fatherweight)
    {
        char ch=strtree[pos];
        pos++;
        if(ch==‘0‘)
        {
            return NULL;
        }
        else
        {
            BitreeNode *T=new BitreeNode();
            T->data=ch;
            T->weight=w[index]+fatherweight;
            index++;
            T->left=CreateBitree(w,T->weight);
            T->right=CreateBitree(w,T->weight);
            return T;
        }
    }
    void preorder(BitreeNode *T)
    {
        if(T!=NULL)
        {
            if(T->left==NULL&&T->right==NULL)
            {
                if(T->weight>maxpath)
                    maxpath=T->weight;
            }
            preorder(T->left);
            preorder(T->right);
        }
        return;
    }
};
 
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        string str;
        cin>>str;
        int n;
        cin>>n;
        int *a=newint[n];
        for(int i=0;i<n;i++)
            cin>>a[i];
        Bitree Tree(a,str);
        Tree.preorder(Tree.Root);
        cout<<Tree.maxpath<<endl;
        delete []a;
    }
    return0;
}