求二叉树中两个节点的最近公共祖先

比如：在如图这棵二叉树中，8和9的公共祖先是1，4和5的公共祖先是2，5和2的公共祖先是2。

在上述分析中，我们可以得出思路，本题解法可分为两种情况，（1）两个节点在根节点同侧 ，则它们的最近公共祖先可能是其中一个节点，也可能是在到两个节点的公共路径上。
（2）两个节点在根节点的不同侧，则它们的公共祖先只能是根节点。

同时，这棵树又分为三种情况：
（1）这棵树是搜索树
（2）这棵树中有三叉链
（3）它只是一棵普通的二叉树

template<class T>
struct BinaryTreeNode
{
    T _data;
    BinaryTreeNode<T>* _left;
    BinaryTreeNode<T>* _right;

    BinaryTreeNode(const T& x)
        :_data(x)
        , _left(NULL)
        , _parent(NULL)
        , _right(NULL)
       {}
};

1，这棵树是搜索树：根据搜索树的性质，它的所有左子树小于根节点，所有右子树大于根节点。
时间复杂度O(N)

Node* GetCommonAncestor(Node* root,Node* x1, Node* x2)
    {
        if (root == NULL)
            return NULL;
        else if ((x1->_data >= root->_data && x2->_data <= root->_data)
            || (x1->_data <= root->_data && x2->_data >= root->_data))
            return root;
        else if (x1->_data < root->_data && x2->_data < root->_data)
            GetCommonAncestor(root->_left, x1, x2);
        else if (x1->_data > root->_data && x2->_data > root->_data)
            GetCommonAncestor(root->_right, x1, x2);
    }

2，普通二叉树
时间复杂度O(N^2)

Node* GetCommonAncesstor(Node* root, Node* x1,Node*x2)
    {
        if (root == NULL)
            return NULL;
        if (x1 == NULL || x2 == NULL)
            return NULL;
        else
        {
            bool X1Inleft, X1Inright, X2Inleft, X2Inright;
            X1Inleft = GetCommonAncesstor(root->_left, x1);
            X1Inright = GetCommonAncesstor(root->_right, x1);
            assert(X1Inleft || X1Inright);
            X2Inleft = GetCommonAncesstor(root->_left, x1);
            X2Inright = GetCommonAncesstor(root->_right, x2);
            assert(X2Inleft || X2Inright);
            if (X1Inleft&&X2Inleft)
                return GetCommonAncesstor(root->_left, x1, x2);
            if (X1Inright&&X2Inright)
                return GetCommonAncesstor(root->_right, x1, x2);
            else
                return root;
        }
    }

优化为O(N)

Node* GetNodePath(Node* root,stack<Node*>& s, Node* x)
    {
        if (root)
            s.push(root);
        if (root->_data == x1->_data)
            return true;
        bool left = GetNodePath(root->_left, s, x);
        if (left)
            return true;
        bool right = GetNodePath(root->_right, s, x);
        if (right);
        return true;
        s.pop();
        return false;
    }

    Node* GetNodeAncestor(Node* root, Node* x1, Node* x2)
    {
        if (NULL == root)
            return NULL;
        assert(x1 && x2);

        stack<Node*> s1, s2;
        if (!GetNodePaths(root, s1, x1) || !GetNodePaths(root, s2, x2))
            return NULL;
        while (s1.size() != s2.size())
        {
            if (s1.size() > s2.size())
                s1.pop();
            if (s1.size() < s2.size())
                s2.pop();
        }

        while (!s1.empty() && !s2.empty() && s1.top() != s2.top())
            {
                    s1.pop();
                    s2.pop();
            }
        return s1.top();
        }

3,这棵二叉树中有三叉链

template<class T>
struct BinaryTreeNode
{
    T _data;
    BinaryTreeNode<T>* _left;
    BinaryTreeNode<T>* _right;
    BinaryTreeNode<T>* _parent;

    BinaryTreeNode(const T& x)
        :_data(x)
        , _left(NULL)
        , _parent(NULL)
        , _right(NULL)
       {}
};

Node* GetCommenAncesstor(Node* root, Node* x1, Node* x2)
    {
        stack<Node*> s1;
        stack<Node*> s2;
        Node* cur1 = x1;
        Node* cur2 = x2;
        while (cur1->_parent)
        {
            if (cur1->_parent->_data == cur2->_data)
                return cur;
            else
                s1.push(cur1);
            cur1 = cur1->_parent;
        }
        while (cur2->_parent)
        {
            if (cur2->_parent->_data == cur1->_data)
                return cur1;
            else
                s2.push(cur2);
            cur2 = cur2->_parent;
        }
        Node* node = NULL;
        while (!s1.empty() && !s2.empty())
        {
            if (s1.pop() == s2.pop())
                node = s1.pop();
            else
                return node;
            s1.pop();
            s2.pop();
        }
        return node;
    }