计算二叉树中节点的最大距离

主要有两种思路。

思路一：

分情况讨论，

• 情况A: 路径经过左子树的最深节点，通过根节点，再到右子树的最深节点。
• 情况B: 路径不穿过根节点，而是左子树或右子树的最大距离路径，取其大者。

计算这两个情况的路径距离，并取其大者，就是该二叉树的最大距离。

struct Node
{
    struct Node * leftChild;
    struct Node * rightChild;
};
struct Result
{
    int nMaxDistance;
    int nMaxDepth;
};

Result GetMaximumDistance(Node* root)
{
    if (!root)
    {
        Result empty = { 0, -1 };
        return empty;
    }
    Result lhs = GetMaximumDistance(root->leftChild);
    Result rhs = GetMaximumDistance(root->rightChild);
    Result result;
    result.nMaxDepth = max(lhs.nMaxDepth + 1, rhs.nMaxDepth + 1);
    result.nMaxDistance = max(max(lhs.nMaxDistance, rhs.nMaxDistance), lhs.nMaxDepth + rhs.nMaxDepth + 2);
    return result;
}

思路二：

计算每个节点的左子树和右子树的高度和，取最大的。

这是原始的解法。

// 数据结构定义
struct NODE
{
    NODE* pLeft;        // 左子树
    NODE* pRight;       // 右子树
    int nMaxLeft;       
    int nMaxRight;      
    char chValue;
};
 
int nMaxLen = 0;
 
void FindMaxLen(NODE* pRoot)
{
    // 遍历到叶子节点，返回
    if(pRoot == NULL)
    {
        return;
    }
 
    if(pRoot -> pLeft == NULL)
    {
        pRoot -> nMaxLeft = 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 Node{
  Node *left;
  Node *right;
};

int tree_height(Node *root, int &max_d)
{
  //每碰到一个子节点，高度自增1，可以设空节点高度为-1
  if (root==NULL) return -1;
  int a = tree_height(root->left, max_d) + 1;   
  int b = tree_height(root->right, max_d) + 1; 
  int c = a+b;
  if (max_d < c) max_d = c;
  return  a>b ? a : b;
}

int maxDis(Node* root)
{
  int max_d=0;
  tree_height(root, max_d);
  return max_d;
}