二叉树中任意两个节点的距离

题目：

一个普通二叉树，如何找到两个给定节点之间的距离？ ，其中二叉树中每个结点的值都不相同

代码1：

#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){}
};

/*用于判断节点值是不是在这个子树上，并求对应的距离*/
bool hasNode(TreeNode* root, int num, int &len)
{
    if (root == nullptr)
        return false;
    queue<TreeNode* > que;
    que.push(root);
    while (!que.empty())
    {
        ++len;
        int size = que.size();
        while (size)
        {
            root = que.front(); que.pop();
            if (root->val == num)
                return true;

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

int shortestDistance(TreeNode* root, int num1, int num2)
{
    if (root == nullptr)
        return 0;

    queue<TreeNode* > que;
    que.push(root);
    while (!que.empty())
    {
        int size = que.size();
        while (size)
        {
            root = que.front(); que.pop();
            if (root->left != nullptr)
                que.push(root->left);
            if (root->right != nullptr)
                que.push(root->right);

            /* 如果一个节点是另一个节点的祖节点，则用下面这两个if求解*/
            if (root->val == num1)
            {
                int left = 0;
                if (hasNode(root->left, num2, left))
                    return left;
                int right = 0;
                if (hasNode(root->right, num2, right))
                    return right;
            }
            if (root->val == num2)
            {
                int left = 0;
                if (hasNode(root->left, num1, left))
                    return left;
                int right = 0;
                if (hasNode(root->right, num1, right))
                    return right;
            }

            /*下面的代码是两个节点有共同的祖节点，但两个节点不在从根结点到叶结点的同一条路径上*/
            int left1 = 0;
            int right1 = 0;
            if (hasNode(root->left, num1, left1) && hasNode(root->right, num2, right1))
            {
                return left1 + right1;
            }
            else
                continue;
            int left2 = 0;
            int right2 = 0;
            if (hasNode(root->left, num2, left2) && hasNode(root->right, num1, right2))
            {
                return left2 + right2;
            }
        }
    }
    return 0;
}



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);
    root->left = node1;
    root->right = node2;
    node1->left = node3;
    node1->right = node4;
    node2->left = node5;
    node2->right = node6;
    cout << shortestDistance(root, 4, 1) << endl;
    return 0;
}

代码2：

int high(TreeNode* root, int num1, int num2)
{
    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->val == num1 || root->val == num2)
            {
                return level;
            }
            if (root->left != nullptr)
                que.push(root->left);
            if (root->right != nullptr)
                que.push(root->right);
            --size;
        }
    }
    return 0;
}

int shortestDistance(TreeNode* root, int num1, int num2)
{
    if (root == nullptr || num1 == num2)
        return 0;
    queue<TreeNode* > que;
    que.push(root);
    while (!que.empty())
    {
        root = que.front();
        que.pop();
        if (root->val == num1 || root->val == num2)
        {
            return high(root->left, num1, num2) + high(root->right, num1, num2);
        }
        if (high(root->left, num1, num2) > 0 && high(root->right, num1, num2) > 0)
        {
            return high(root->left, num1, num2) + high(root->right, num1, num2);
        }
        if (root->left != nullptr)
            que.push(root->left);
        if (root->right != nullptr)
            que.push(root->right);
    }
    return 0;
}