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

第一种方法，按照题目意思输入n个结点，把n个节点放在一个数组，再把数组内的值赋给结点，需要定义全局变量

#include<iostream>
#include<algorithm>
using namespace std;
 
int n[100],m,j; //定义了全局变量
 
class Node {
    public:
        char data;
        int quan;
        Node *lchild, *rchild;
        Node(char _data) {
            data = _data;
            lchild = NULL;
            rchild = NULL;
        }
        Node() {
            lchild = NULL;
            rchild = NULL;
        }
        ~Node() {
            if (lchild != NULL) {
                delete lchild;
            }
            if (rchild != NULL) {
                delete rchild;
            }
        }
};
class BinaryTree {
    public:
        Node *root;
        void build(Node *&tree) {
            char c;
            cin>>c;
            if(c == '0') {
                tree = NULL ;
            }
            if(c != '0') {
                tree = new Node(c);
                build(tree->lchild);
                build(tree->rchild);
            }
        }
        BinaryTree() {
            root = NULL;
        }
        ~BinaryTree() {
            delete root;
        }
        void build() {
            build(root);
        }
 
};
int height(Node* node) {
    if(!node) return 0;
    return max(height(node->lchild),height(node->rchild)) + node->quan;
}
 
void in_put(Node *&node) {
    if(!node) return;
    node->quan = n[j++];
    in_put(node->lchild);
    in_put(node->rchild);
     
}
void pre_order_node(Node *node) {
    if (node == NULL) return ;
    printf("%d ", node->quan);
    pre_order_node(node->lchild);
    pre_order_node(node->rchild);
    return ;
}
 
int main() {
    int t;
    cin>>t;
    while(t--) {
        BinaryTree binarytree;
        binarytree.build();
        cin>>m;
        j = 0;
    for(int i = 0; i < m;i++){
        cin>>n[i];
    }
        in_put(binarytree.root);
        cout<<height(binarytree.root)<<endl;
    }
    return 0;
 }

第二种方法，因为在创建树的时候，已经确定了结点数，完全不需要输入结点数n， 不需要定义全局变量，只需要利用树的递归即可完成

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

class Node {
	public:
		char data;
		int quan;
		Node *lchild, *rchild;
		Node(char _data) {
			data = _data;
			lchild = NULL;
			rchild = NULL;
		}
		Node() {
			lchild = NULL;
			rchild = NULL;
		}
		~Node() {
			if (lchild != NULL) {
				delete lchild;
			}
			if (rchild != NULL) {
				delete rchild;
			}
		}
};
class BinaryTree {
	public:
		Node *root;
		void build(Node *&tree) {
			char c;
			cin>>c;
			if(c == '0') {
				tree = NULL ;
			}
			if(c != '0') {
				tree = new Node(c);
				build(tree->lchild);
				build(tree->rchild);
			}
		}
		BinaryTree() {
			root = NULL;
		}
		~BinaryTree() {
			delete root;
		}
		void build() {
			build(root);
		}

};
int road(Node* node) {
	if(!node) return 0;
	return max(road(node->lchild),road(node->rchild)) + node->quan;
} 

void in_put(Node *&node) {
	if(!node) return;
	cin>>node->quan; //	在每个结点输入权值即可 
	in_put(node->lchild);
	in_put(node->rchild);
}

int main() {
	int t;
	cin>>t;
	while(t--) {
		BinaryTree binarytree;
		binarytree.build();
		char temp;
		cin>>temp;   //将输入结点数n 吃掉，不需要用到这个值 
		in_put(binarytree.root);
		cout<<road(binarytree.root)<<endl;
	}
	return 0;
}