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

要求考虑以下三种种情况，给出解决方案，并解决：

1：二叉树每个节点有parent（三叉链）

2：二叉树是搜索二叉树。

3：就是普通二叉树。（尽可能实现时间复杂度为O（N））

求两个结点的最近公共祖先有两种情况。

1、如果这两个结点不在一条线上，则它们就分别在最近的公共祖父的左右子树上。

2、如果这两个结点在一条线上，则它们之中深度最前的就是他们的最近的公共祖先。

1：三叉链。在这种情况下，我们可以分别用两个数据结构来保存两个节点到根节点的路径，然后通过对比，找到最近公共祖先。

/*
//三叉链
struct Node
{
int _data;
Node* _left;
Node* _right;
Node* _parent;
Node(const int& x)
: _data(x)
, _left(NULL)
, _right(NULL)
, _parent(NULL)
{}
};
*/
Node* GetLastestCommonAncestor4(Node* root, Node* x1, Node* x2)
{
assert(x1 && x2);
if (root == NULL)
return NULL;

stack<Node*> s1;
stack<Node*> s2;

//x1
Node* cur1 = x1;
while (cur1->_parent)
{
s1.push(cur1);
cur1 = cur1->_parent;
}

//x2
Node* cur2 = x2;
while (cur2->_parent)
{
s2.push(cur2);
cur2 = cur2->_parent;
}

//走到这里，两个栈中分别保存了x1和x2到根节点的路径
while (s1.size() != s2.size())
{
if (s1.size() > s2.size())
s1.pop();
else
s2.pop();
}

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

if (s1.top() == s2.top())
return s1.top();
return NULL;
}

2：二叉树是搜索二叉树，对于搜索树来说，左子树的节点都比根节点小，右子树的节点都比根节点大。根据搜索树这样的特征，我们可以有以下思路。

（1）如果一个节点比根节点小，另一个节点比根节点大， 则根节点为最近公共祖先；

（2）如果两个节点均比根节点小，则最近公共祖先在左子树；

（3）如果两个节点均比根节点大，则最近公共祖先在右子树。

有了这样的思路，我们可以通过递归，实现查找最近公共祖先。

struct Node
{
int _data;
Node* _left;
Node* _right;
Node(const int& x)
: _data(x)
, _left(NULL)
, _right(NULL)
{}
};

Node* GetLastestCommonAncestor1(Node* root, Node* x1, Node* x2)
{
assert(x1&&x2);
if (root == NULL)
return NULL;
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)
return GetLastestCommonAncestor1(root->_left, x1, x2);
else
return GetLastestCommonAncestor1(root->_right, x1, x1);
}

3：普通二叉树

可以分别使用上面两种特殊情况的思想来处理普通二叉树

struct Node
{
int _data;
Node* _left;
Node* _right;
Node(const int& x)
: _data(x)
, _left(NULL)
, _right(NULL)
{}
};

//普通二叉树（搜索二叉树思想）
bool IsInTree(Node* root, Node* x)
{
if (root == NULL)
return false;
if (root->_data == x->_data)
return true;
else
return IsInTree(root->_left, x) || IsInTree(root->_right, x);
}

Node* GetLastestCommonAncestor2(Node* root, Node* x1, Node* x2)
{
assert(x1 && x2);
if (root == NULL)
return NULL;
bool x1InLeft, x1InRight, x2InLeft, x2InRight;
x1InLeft = IsInTree(root->_left, x1);
x1InRight = IsInTree(root->_right, x1);
assert(x1InLeft || x1InRight);

x2InLeft = IsInTree(root->_left, x2);
x2InRight = IsInTree(root->_right, x2);
assert(x2InLeft || x2InRight);

if ((x1InLeft && x2InRight) || (x1InRight && x2InLeft))
return root;
else if (x1InLeft&&x2InLeft)
return GetLastestCommonAncestor2(root->_left, x1, x2);
else
return GetLastestCommonAncestor2(root->_right, x2, x2);
}

//普通二叉树（三叉链方法的思想）
bool GetNodePaths(Node* root, Node* x, stack<Node*>& s)
{
if (root == NULL)
return;
s.push(root);
if (root == x)
return true;
bool inLeft = GetNodePaths(root->_left, x, s);
if (inLeft)
return true;
bool inRight = GetNodePaths(root->_right, x, s);
if (inRight)
return true;
s.pop();
return false;
}

Node* GetLastestCommonAncestor3(Node* root, Node* x1, Node* x2)
{
assert(x1&&x2);
if (root == NULL)
return NULL;
stack<Node*> paths1, paths2;
if (!GetNodePaths(root, x1, paths1)   || !GetNodePaths(root, x2, paths2))
return NULL;

while (paths1.size() != paths2.size())
{
if (paths1.size() > paths2.size())
paths1.pop();
else
paths2.pop();
}

while (!paths1.empty() && !paths2.empty() && paths1.top() != paths2.top())
{
paths1.pop();
paths2.pop();
}

if (paths1.top() == paths2.top())
return paths1.top();
return NULL;
}