剑指offer 面试题50 树中两个节点的最低公共祖先

// 剑指offer 面试题50 树中两个节点的最低公共祖先
#include <iostream>
#include <list>
#include <vector>
using namespace std;

struct TreeNode
{
    char value;
    vector<TreeNode*> m_vChildren;

    TreeNode(char v) : value(v) {}
};

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;
    list<TreeNode*> path2;

    GetNodePath(pRoot, pNode1, path1);
    GetNodePath(pRoot, pNode2, path2);

    return GetLastCommonNode(path1, path2);
}

void Test1()
{
    TreeNode* pRoot = new TreeNode('A');
    TreeNode* pNodeB = new TreeNode('B');
    TreeNode* pNodeC = new TreeNode('C');

    pRoot->m_vChildren.push_back(pNodeB);
    pRoot->m_vChildren.push_back(pNodeC);

    TreeNode* pNodeD = new TreeNode('D');
    TreeNode* pNodeE = new TreeNode('E');

    pNodeB->m_vChildren.push_back(pNodeD);
    pNodeB->m_vChildren.push_back(pNodeE);

    TreeNode* pNodeF = new TreeNode('F');
    TreeNode* pNodeG = new TreeNode('G');

    pNodeD->m_vChildren.push_back(pNodeF);
    pNodeD->m_vChildren.push_back(pNodeG);

    TreeNode* pNodeH = new TreeNode('H');
    TreeNode* pNodeI = new TreeNode('I');
    TreeNode* pNodeJ = new TreeNode('J');

    pNodeE->m_vChildren.push_back(pNodeH);
    pNodeE->m_vChildren.push_back(pNodeI);
    pNodeE->m_vChildren.push_back(pNodeJ);

    TreeNode* pLastCommon = GetLastCommonParent(pRoot, pNodeF, pNodeG);
    cout << pLastCommon->value << endl;

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