算法题目---树中两个结点的最低公共祖先

求在一棵树中，两个结点的最低公共祖先结点。

#include<iostream>

#include<vector>
#include<list>
#include<stdio.h>

using namespace std;

struct TreeNode
{
    int m_nValue;
    vector<TreeNode*> m_vChildren;
};

TreeNode* CreateTreeNode(int value)
{
    TreeNode* pNode = new TreeNode();
    pNode->m_nValue = value;
    
    return pNode;

}

void ConnectTreeNodes(TreeNode* pParent,TreeNode* pChild)
{
    if(pParent != NULL)
    {
        pParent->m_vChildren.push_back(pChild);
    }
}

void PrintTreeNode(TreeNode* pNode)
{
    if(pNode != NULL)
    {
        printf("value of this node is: %d.\n",pNode->m_nValue);
        printf("its children is as the following: \n");
        
        vector<TreeNode*>::iterator i = pNode->m_vChildren.begin();
        while(i < pNode->m_vChildren.end())
        {
            if(*i != NULL)
                printf("%d\t",(*i)->m_nValue);
                ++i;
        }
        printf("\n");
    }
    else
    {
        printf("this node is null.\n");
    }
    printf("\n");
}

void PrintTree(TreeNode* pRoot)
{
    PrintTreeNode(pRoot);
    
    if(pRoot != NULL)
    {
        vector<TreeNode*>::iterator i = pRoot->m_vChildren.begin();
        while(i < pRoot->m_vChildren.end())
        {
            PrintTree(*i);
            ++i;
        }
    }
}

void DestroyTree(TreeNode* pRoot)
{
    if(pRoot != NULL)
    {
        std::vector<TreeNode*>::iterator i = pRoot->m_vChildren.begin();
        while( i < pRoot->m_vChildren.end())
        {
            DestroyTree(*i);
             ++i;
        }
        delete pRoot;        
    }
}


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

TreeNode* GetLastCommonNode(const list<TreeNode*>&path1,const list<TreeNode*>&path2)
{
    list<TreeNode*>::const_iterator iterator1 = path1.begin();
    list<TreeNode*>::const_iterator iterator2 = path2.begin();
    
    TreeNode* pLast = NULL;
    
    while(iterator1 != path1.end() && iterator2 != path2.end())
    {
        if(*iterator1 == *iterator2)
            pLast = *iterator1;
        
        iterator1++;
        iterator2++;    
    }
    return pLast;
}

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

void test()
{
    TreeNode* node1 = CreateTreeNode(1);
    TreeNode* node2 = CreateTreeNode(2);
    TreeNode* node3 = CreateTreeNode(3);
    TreeNode* node4 = CreateTreeNode(4);
    TreeNode* node5 = CreateTreeNode(5);
    TreeNode* node6 = CreateTreeNode(6);
    TreeNode* node7 = CreateTreeNode(7);
    TreeNode* node8 = CreateTreeNode(8);
    TreeNode* node9 = CreateTreeNode(9);
    TreeNode* node10 = CreateTreeNode(10);
    TreeNode* node11 = CreateTreeNode(11);
    TreeNode* node12 = CreateTreeNode(12);
    TreeNode* node13 = CreateTreeNode(13);
    TreeNode* node14 = CreateTreeNode(14);

    ConnectTreeNodes(node1,node2);
    ConnectTreeNodes(node1,node3);
    ConnectTreeNodes(node1,node13);
    ConnectTreeNodes(node1,node14);
    ConnectTreeNodes(node2,node4);
    ConnectTreeNodes(node2,node5);
    ConnectTreeNodes(node4,node6);
    ConnectTreeNodes(node4,node7);
    ConnectTreeNodes(node5,node8);
    ConnectTreeNodes(node5,node9);
    ConnectTreeNodes(node6,node10);
    ConnectTreeNodes(node6,node11);

    PrintTree(node1);
    TreeNode* node = GetLastCommonParent(node1,node8,node10);
    printf("node %d\n",node->m_nValue);

}

int main()
{
    test();
    return 0;
}