求一棵普通树的两个结点的最低公共祖先

一棵普通树，树中的结点没有指向父节点的指针，求一棵普通树的两个结点的最低公共祖先。

代码如下，我太懒没有加注释，大家自己看吧！

#include <iostream>
#include <list>
#include <vector>
using namespace std;

struct TreeNode //节点
{
    char m_nValue;
    vector<TreeNode*> m_vChildren;
};

TreeNode* ConstructTree(TreeNode** pNode1 , TreeNode** pNode2)
{
    TreeNode* A = new TreeNode();
    A->m_nValue = 'A';
    TreeNode* B = new TreeNode();
    B->m_nValue = 'B';
    TreeNode* C = new TreeNode();
    C->m_nValue = 'C';
    TreeNode* D = new TreeNode();
    D->m_nValue = 'D';
    TreeNode* E = new TreeNode();
    E->m_nValue = 'E';
    TreeNode* F = new TreeNode();
    F->m_nValue = 'F';
    TreeNode* G = new TreeNode();
    G->m_nValue = 'G';
    TreeNode* H = new TreeNode();
    H->m_nValue = 'H';
    TreeNode* I = new TreeNode();
    I->m_nValue = 'I';
    TreeNode* J = new TreeNode();
    J->m_nValue = 'J';


    A->m_vChildren.push_back(B);
    A->m_vChildren.push_back(C);
    B->m_vChildren.push_back(D);
    B->m_vChildren.push_back(E);
    D->m_vChildren.push_back(F);
    D->m_vChildren.push_back(G);
    E->m_vChildren.push_back(H);
    E->m_vChildren.push_back(I);
    E->m_vChildren.push_back(J);

    *pNode1 = F;
    *pNode2 = G;
    return A;
}



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

TreeNode* GetLastCommonNode(list<TreeNode*>& path1 , list<TreeNode*>& path2 )
{
    if (path1.empty() || path2.empty())
    {
        return NULL;
    }
    list<TreeNode*>::const_iterator it1 = path1.begin();
    list<TreeNode*>::const_iterator it2 = path2.begin();
    TreeNode* temp = NULL ;
    while ( it1 != path1.end() && it2 != path2.end() && (*it1 == *it2))
    {
        temp = *it1 ;
        it1++;
        it2++;
    }

    return temp;
}

TreeNode* GetLastCommonParent(TreeNode* pRoot, TreeNode* pNode1, TreeNode* pNode2)
{
    if (pRoot == NULL || pNode1 == NULL || pNode2 == NULL)
    {
        return NULL;
    }
    list<TreeNode*> path1 ;
    GetNodePath(pRoot, pNode1, path1);

    list<TreeNode*> path2 ;
    GetNodePath(pRoot, pNode2, path2);
    
    return GetLastCommonNode(path1, path2);
}



int main()
{
    TreeNode *pNode1 = NULL , *pNode2 = NULL ;
    TreeNode* pRoot = ConstructTree(&pNode1, &pNode2);
    TreeNode* LastCommonParent = GetLastCommonParent(pRoot, pNode1, pNode2);

    cout<<LastCommonParent->m_nValue<<endl;
    getchar();
    return 0;

}