编程之美3.8 求二叉树中节点的最大距离

11. 求二叉树中节点的最大距离

如果我们把二叉树看成一个图，父子节点之间的连线看成是双向的，我们姑且定义"距离"为两节点之间边的个数。

写一个程序，求一棵二叉树中相距最远的两个节点之间的距离。

分析： 对任意一个节点，以该节点为根，假设这个根有k个孩子节点，那么相距最远的两个节点U和V之间的路径与这个根节点的关系有两种情况。

1.若路径经过根Root，则U和V是属于不同的子树的，且它们都是该子树中到根节点最远的节点，否则跟它们的距离最远相矛盾。

2.若路径不经过Root，那它们一定同属于根的左子树或右子树，并且它们也是该子树中相距最远的两个顶点。

因此，问题就可以转化为在子树上的解，从而能够利用动态规划来解决。

#include <iostream>
using namespace std;
struct NODE
{
NODE* pLeft;        // 左子树
NODE* pRight;       // 右子树
int nMaxLeft;       // 左子树中的最长距离
int nMaxRight;      // 右子树中的最长距离
char chValue;       // 该节点的值
NODE(char c = '\0'):pLeft(NULL), pRight(NULL), nMaxLeft(0), nMaxRight(0), chValue(c){}
};
int nMaxLen = 0;

// 寻找树中最长的两段距离
void FindMaxLen(NODE* pRoot)
{
// 遍历到叶子节点，返回
if(pRoot == NULL)
{
return;
}
// 如果左子树为空，那么该节点的左边最长距离为0
if(pRoot -> pLeft == NULL)
{
pRoot -> nMaxLeft = 0;
}
// 如果右子树为空，那么该节点的右边最长距离为0
if(pRoot -> pRight == NULL)
{
pRoot -> nMaxRight = 0;
}
cout << pRoot->chValue << endl;
// 如果左子树不为空，递归寻找左子树最长距离
if(pRoot -> pLeft != NULL)
{
FindMaxLen(pRoot -> pLeft);
}
// 如果右子树不为空，递归寻找右子树最长距离
if(pRoot -> pRight != NULL)
{
FindMaxLen(pRoot -> pRight);
}
// 计算左子树最长节点距离
if(pRoot -> pLeft != NULL)
{
int nTempMax = 0;
if(pRoot -> pLeft -> nMaxLeft > pRoot -> pLeft -> nMaxRight)
{
nTempMax = pRoot -> pLeft -> nMaxLeft;
}
else
{
nTempMax = pRoot -> pLeft -> nMaxRight;
}
pRoot -> nMaxLeft = nTempMax + 1;
cout << "pRoot-left-MaxRight " << pRoot->chValue << " " <<  pRoot -> nMaxRight << endl;
}

// 计算右子树最长节点距离
if(pRoot -> pRight != NULL)
{
int nTempMax = 0;
if(pRoot -> pRight -> nMaxLeft > pRoot -> pRight -> nMaxRight)
{
nTempMax = pRoot -> pRight -> nMaxLeft;
}
else
{
nTempMax = pRoot -> pRight -> nMaxRight;
}
pRoot -> nMaxRight = nTempMax + 1;
cout << "pRoot-right-MaxRight " << pRoot->chValue << " " <<  pRoot -> nMaxRight << endl;
}
// 更新最长距离
if(pRoot -> nMaxLeft + pRoot -> nMaxRight > nMaxLen)
{
nMaxLen = pRoot -> nMaxLeft + pRoot -> nMaxRight;
cout << "nMaxLen " << pRoot->chValue << " " <<  nMaxLen << endl;
}
}
int main()
{
NODE node[9];
/*
for (char i = '1'; i <= '9'; ++i)
{
node[i-'1'].chValue = i;
}
node[0].pLeft = &node[1];
node[0].pRight = &node[8];
node[1].pLeft = &node[2];
node[1].pRight = &node[5];
node[2].pLeft = &node[3];
node[3].pLeft = &node[4];
node[5].pRight = &node[6];
node[6].pRight = &node[7];
*/
for (char i = '1'; i <= '9'; ++i)
{
node[i-'1'].chValue = i;
}
node[0].pLeft = &node[1];
node[0].pRight = &node[2];
node[1].pLeft = &node[3];
node[1].pRight = &node[4];
node[2].pLeft = &node[5];
node[2].pRight = &node[6];
node[3].pLeft = &node[7];
node[5].pRight = &node[8];
FindMaxLen(&node[0]);
cout << "MaxLengthFin " << nMaxLen << endl;
system("pause");
return 0;
}