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

题目：

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

Example：

上面二叉树的最大距离为5，路径为4-2-1-3-6-8

解法：

一个以h为头的树上,最大距离只可能来自以下三种情况

• h的左子树上的最大距离
• h的右子树上的最大距离
• h左子树上离h.left最远的距离+1(h)+h右子树上离h.right最远的距离。

三个值中最大的那个就是整棵h树中最远的距离。

递归法：

#include <iostream>
#include <vector>
#include <queue>

using namespace std;

struct TreeNode
{
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x):val(x), left(nullptr), right(nullptr){}
};

int posOrder(TreeNode* root, int &record)
{
    if (root == nullptr)
    {
        record = 0;
        return 0;
    }
    int maxfromLeft;
    int lmax = posOrder(root->left, maxfromLeft);

    int maxfromRight;
    int rmax = posOrder(root->right, maxfromRight);

    int curmax = maxfromLeft + maxfromRight;
    record = max(maxfromLeft, maxfromRight) + 1;
    return max(max(lmax, rmax), curmax);
}

int maxDistance(TreeNode* root)
{
    int record = 0;
    return posOrder(root, record);
}


int main()
{
    TreeNode* root = new TreeNode(1);
    TreeNode* node1 = new TreeNode(2);
    TreeNode* node2 = new TreeNode(3);
    TreeNode* node3 = new TreeNode(4);
    TreeNode* node4 = new TreeNode(5);
    TreeNode* node5 = new TreeNode(6);
    TreeNode* node6 = new TreeNode(7);
    TreeNode* node7 = new TreeNode(8);
    root->left = node1;
    root->right = node2;
    node1->left = node3;
    node1->right = node4;
    node2->left = node5;
    node2->right = node6;
    node5->right = node7;
    cout << maxDistance(root) << endl;
    return 0;
}

非递归法：

int high(TreeNode* root)
{
    if (root == nullptr)
        return 0;
    queue<TreeNode* > que;
    que.push(root);
    int level = 0;
    while (!que.empty())
    {
        ++level;
        int size = que.size();
        while (size != 0)
        {
            root = que.front(); que.pop();

            if (root->left != nullptr)
                que.push(root->left);
            if (root->right != nullptr)
                que.push(root->right);
            --size;
        }
    }
    return level;
}

int maxDistance(TreeNode* root)
{
    if (root == nullptr)
        return 0;
    queue<TreeNode* > que;
    que.push(root);
    int maxPath = 0;
    while (!que.empty())
    {
        root = que.front();
        que.pop();

        maxPath = max(maxPath, (high(root->left) + high(root->right)));
        if (root->left != nullptr)
            que.push(root->left);
        if (root->right != nullptr)
            que.push(root->right);
    }
    return maxPath;
}