DS二叉树—二叉树结点的最大距离

题目描述 二叉树两个结点的距离是一个结点经过双亲结点，祖先结点等中间结点到达另一个结点经过的分支数。二叉树结点的最大距离是所有结点间距离的最大值。例如，下图所示二叉树结点最大距离是3，C和D的距离。

  A
 /  \
B    D
 \
  C

二叉树用先序遍历顺序创建，#表示空树。计算二叉树结点最大距离和最大距离的两个结点。

如果有多个解，输出字典序最小的解（即第一个结点字母更小的，如果第一个字母相同，输出第二个结点字母更小的）。

输入

测试次数T
第2行之后的T行，每行为一棵二叉树先序遍历结果（#表示空树）

输出

对每棵二叉树，输出树的结点最大距离和最大距离的结点，输出格式见样例。

样例输入

3
A##
ABC##EF#G###D##
ABEH###F#K###

样例输出

0:
5:D G
4:H K

#include <iostream>
#include <string>
#include <cstring>
using namespace std;
int Max_Dis[100];
char lc[100];
char rc[100];
int I = 0;
class Binary_tree_node
{
public:
    char data;                    //数据域
    Binary_tree_node *LeftChild;  //左孩子
    Binary_tree_node *RightChild; //右孩子
    Binary_tree_node()
    {
        LeftChild = NULL;
        RightChild = NULL;
    }
    ~Binary_tree_node()
    {
        delete LeftChild;
        delete RightChild;
    }
};

class Binary_tree
{
public:
    Binary_tree_node *Root; //根结点
    int pos;                //位置
    string strTree;         //字符串树
    int deep;               //深度
    int leftdeep;           //左子树深度
    int rightdeep;          //右子树深度
    char left_ch;           //左子树叶子结点值
    char right_ch;          //右子树叶子结点值
    char ch;                //字符
    int md;                 //最大距离
    Binary_tree(string str)
    {
        pos = 0;
        deep = 0;
        leftdeep = 0;
        rightdeep = 0;
        md = 0;
        strTree = str;
        Root = CreateBiTree();
    }
    //先序遍历建立二叉树
    Binary_tree_node *CreateBiTree() 
    {
        char ch = strTree[pos];
        pos++;
        if (ch == '#') //#表示空结点
        {
            return NULL;
        }
        else //非空结点
        {
            Binary_tree_node *T;
            T = new Binary_tree_node();
            T->data = ch;
            T->LeftChild = CreateBiTree();
            T->RightChild = CreateBiTree();
            return T;
        }
    }
    //计算左孩子结点层数及获取其叶子结点的值
    void countleftdeep(Binary_tree_node *p) 
    {
        if (p->LeftChild == NULL)
        {
            leftdeep = 0;
            left_ch = p->data;
        }
        else
        {
            p = p->LeftChild;
            countdeep(p, 0);
            leftdeep = deep;
            left_ch = ch;
        }
    }
    //计算右孩子结点层数及获取其叶子结点的值
    void countrightdeep(Binary_tree_node *p) 
    {
        if (p->RightChild == NULL)
        {
            rightdeep = 0;
            right_ch = p->data;
        }
        else
        {
            p = p->RightChild;
            countdeep(p, 0);
            rightdeep = deep;
            right_ch = ch;
        }
    }
    //计算二叉树的深度
    void countdeep(Binary_tree_node *p, int i) 
    {
        if (p != NULL) //不为空树
        {
            i++;
            if (p->LeftChild == NULL && p->RightChild == NULL)
            {
                if (deep < i)
                {
                    deep = i;
                    ch = p->data;
                }
            }
            countdeep(p->LeftChild, i);
            countdeep(p->RightChild, i);
        }
    }
    void Calculate_distance(Binary_tree_node *p)
    {
        if (p != NULL)
        {
            deep = 0;
            countleftdeep(p); 
            deep = 0;
            countrightdeep(p); 
            deep = 0;
            md = leftdeep + rightdeep;
            Max_Dis[I] = md;
            lc[I] = left_ch;
            rc[I] = right_ch;
            I++;
            Calculate_distance(p->LeftChild);
            Calculate_distance(p->RightChild);
        }
    }
};

int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        for (int i = 0; i < I; i++)
        {
            Max_Dis[i] = 0;
        }
        //初始化lc和rc为0
        memset(lc, 0, sizeof(lc));
        memset(rc, 0, sizeof(lc));
        I = 0;
        string str;
        cin >> str;
        Binary_tree Bt(str);
        Bt.Calculate_distance(Bt.Root);
        int m = Max_Dis[0];
        //比较计算出结点间距离的最大值
        int index = 0;
        for (int i = 0; i < I; i++)
        {
            if (Max_Dis[i] > m)
            {
                index = i;
            }
        }
        cout << Max_Dis[index] << ":";
        if (Max_Dis[index] != 0)
        {
            cout << lc[index] << " " << rc[index] << endl;
        }
        else
        {
            cout << endl;
        }
    }
    return 0;
}