微软面试100题之11题：求二叉树中节点的最大距离

题目：求二叉树中节点的最大距离

如果我们把二叉树看成一个图，父子节点之间的连线看成是双向的，

我们姑且定义"距离"为两节点之间边的个数。
写一个程序，

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

分析如下：

如图3-11所示，粗箭头的边表示最长距离：

 

分析与解法

我们先画几个不同形状的二叉树，（如图3-12所示），看看能否得到一些启示。

从例子中可以看出，相距最远的两个节点，一定是两个叶子节点，或者是一个叶子节点到它的根节点。（为什么？）

 

解法一

根据相距最远的两个节点一定是叶子节点这个规律，我们可以进一步讨论。

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

1.      若路径经过根Root，则U和V是属于不同子树的，且它们都是该子树中道根节点最远的节点，否则跟它们的距离最远相矛盾。这种情况如图3-13所示：

2.      如果路径不经过Root，那么它们一定属于根的K个子树之一。并且它们也是该子树中相距最远的两个顶点。如图3-14中的节点A：

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

 

设第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-15，只需要遍历所有的节点一次，时间复杂度为O(|E|)=O(|V|-1)，其中V为点的集合，E为边的集合。

 

示例代码如下，我们使用二叉树来实现该算法。

//数据结构定义

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;

}

下面给出另一个程序：

int maxDistance(Node * root) {
  int depth;
  return helper(root, depth);
}
int helper(Node * root, int &depth) {
  if (root == NULL) {
    depth = 0; return 0;
  }
  int ld, rd;
  int maxleft = helper(root->left, ld);
  int maxright = helper(root->right, rd);
  depth = max(ld, rd)+1;
  return max(maxleft, max(maxright, ld+rd));
}

这两个例子的思想是一样的，都用到了函数的递归