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

1.问题描述

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

如下图：

2.分析与解法

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

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

2).如果路径不经过Root，那么它们一定属于根的k个子树之一，并且它们也是该子树中相距最远的两个顶点

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

设第K棵子树中相距最远的两个节点：Uk和Vk，其距离定义为d(Uk,Vk)，那么节点Uk或Vk即为子树K到根节点Rk距离最长的节点。不失一般性，我们设Uk为子树K中道根节点Rk距离最长的节点，其到根节点的距离定义为d(Uk,R)。取d(Ui,R)(1<=i<=k)中最大的两个值max1和max2，那么经过根节点R的最长路径为max1+max2+2，所以树R中相距最远的两个点的距离为：max{d(U1,V1),…, d(Uk,Vk),max1+max2+2}。

3.代码实现

编程之美给出的代码如下：

//数据结构定义
struct NODE
{
       NODE* pLeft;       //左孩子
       NODE* pRight;      //右孩子
       int nMaxLeft;      //左孩子中的最长距离
       int nMaxRight;     //右孩子中的最长距离
       char chValue;      //该节点的值
};

 

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;
      }
 
      //如果左子树不为空，递归寻找左子树最长距离
      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;
      }

      //计算右子树最长节点距离
      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;
       }

     //更新最长距离
     if(pRoot->nMaxLeft+pRoot->nMaxRight > nMaxLen)
     {
               nMaxLen=pRoot->nMaxLeft+pRoot->nMaxRight;
     } 
}

依据二叉树寻找最大深度的常规思想，又有代码如下：

struct BTNode
{
       int data;
       BTNode* pLeft;
       BTNode* pRight;
};


int maxDis = -1;

int findMaxDis(BTNode* pRoot)
{
    
     if(pRoot == NULL)
            return 0;
     
     int maxLeft  = findMaxDis(pRoot->pLeft) ;
     int maxRight = findMaxDis(pRoot->pRight);
     
     if(maxLeft + maxRight > maxDis)
     {
            maxDis = maxLeft + maxRight;
     } 
     
     return maxLeft > maxRight ? maxLeft+1 : maxRight+1;
} 

后一段代码为自写 没有验证其正确性。