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

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

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

如果有父亲结点，那就可以反向遍历当成两个链表找第一个公共结点即可。
这时候头为两个结点，尾为二叉树的根节点

BinaryTreeNode* GetLastCommonAncestor(BinaryTreeNode* pRoot, BinaryTreeNode* p1,BinaryTreeNode* p2)
{
     if(pRoot != NULL && p1 != NULL && p2 != NULL)
     {
          //给两个链表去分别存储两个结点到根的路径
          BinaryTreeNode* list1 = p1;
          BinaryTreeNode* list2 = p2;

          int len1 = 0;
          int len2 = 0;

          while(list1 != pRoot)
          {
               list1 = list1 -> parent;
               ++len1;
          }

          while(list2 != pRoot)
          {
               list2 = list2 -> parent ;
               ++len2;
          }

          int len = len2 - len1;
          if(len < 0)
               len = 0-len;

          //如果链表1比较长，则让链表一先走len步
          if(len1 > len2)
          {
               while(len1 >= len)
               {   
                    list1 = list1 ->parent ;
                    --len1;
               }
          }
          else
          {
               //否则让链表2走len步
               while(len2 >=len)
               {
                    while(len2 >= len)
                    {   
                         list2 = list2 ->parent ;
                         --len2;
                    }
               }
          }

          while(list1 != list2)
          {
               list1 = list1 -> parent ;
               list2 = list2 -> parent ;
          }

          return list1;
     }
     return NULL;
}

类型2：二叉树是搜索二叉树。
如果是二叉搜索树，则是排过序的，则左边的都比根小右边的都比根大。所以用两个结点的值和根比较，
如果两个结点都比根大则一定在根的左子树中。如果两个节点都比跟小，则一定在右子树中如果一个比根大一个比根小，则这个根节点就是最低的祖先节点。

BinaryTreeNode* GetLastCommonAncestor(BinaryTreeNode* pRoot,BinaryTreeNode * p1,BinryTreeNode* p2)
{    
     BinaryTreeNode* pCur = NULL;
     if(pRoot != NULL && p1 != NULL && p2 != NULL)
     {
          queue<BinaryTreeNode*>q;
          q.push(pRoot);
          while( !q.empty() )
          {
               pCur = q.front();
               q.pop();
               if(p1 -> value > pCur -> value && p2 -> value > pCur -> value)
                    q.push(pCur -> right);
               else if(p1 -> value < pCur -> value && p2 -> value < pCur -> value)
                    q.push(pCur -> right);
               else 
                    return pCur;
          }
     }
}

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

思路：还是当做链表来处理，如果向下找没找到一个，就push。如果走到空或者这个节点的子节点遍历完了都没有找到，则pop。
则再取最后的链表一个，看他的另外一个孩子，如果找到了，则看另外一个链表。
最后找两个链表的公共结点。

//获取路径，对孩子结点进行递归式的遍历。
bool GetNodePath(BinaryTreeNode* pRoot,BinaryTreeNode* pNode,list<BinaryTreeNode*>& path)
{
     if(pRoot == pNode)
          return true;

     path.push_back(pRoot);
     bool found = false;
     vector<BinaryTreeNode*>::iterator it = pRoot -> children.begin();
     while(!found && it < pRoot -> children.end())
     {
          found = GetNodePath(*it,pNode,path);
          ++it;
     }
     if(!found)
          path.pop_back();
     return found;
}

//获取公共结点
TreeNode* GetLastCommonNode(const list<TreeNode*>& path1,const list<TreeNode*>& path2)
{
     list<TreeNode*> :: iterator it1 = path1.begin();
     list<TreeNode*> :: iterator it2 = path2.begin();

     TreeNode* pLast = NULL;
     while(it1 != path.end() && it2 != path2.end())
     {
          if(*it1 == *it2)
               pLast = *it1;
          it1++;
          it2++;
     }
     return pLast;
}

//汇总，先获取路径再获取最近的公共结点
TreeNode* GetLastCommonParent(BinaryTreeNode* pRoot,BinaryTreeNode *pNode1,BinaryTreeNode *pNode2)
{
     if(pRoot == NULL || pNode1 == NULL || pNode2 ==NULL)
               return NULL;
     list<BinaryTreeNode*>path1;
     GetNodePath(pRoot,pNode1,path2);

     list<BinaryTreeNode*>path2;
     GetNodePath(pRoot,pNode2,path2);

     return GetLastCommonNode(path1,path2);
}