/////////////////主文件

#include <iostream>

#include <vector>

#include <list>

#include “Tree.h”

using namespace std;

bool FindPath(TreeNode* pRoot, TreeNode* pNode, list<TreeNode*>& tree_list)

{

if (pRoot == pNode)

return true;

tree_list.push_back(pRoot);

bool found = false;

vector<TreeNode*>::iterator iter = pRoot->m_children.begin();

while (!found&&iter<pRoot->m_children.end())

{

found=FindPath(*iter, pNode, tree_list);
//递归进行入队列

iter++;

}

if (!found)

{

tree_list.pop_back();
//没有找到节点，则出队列，进行回溯遍历

}

return found;

}

TreeNode* GetLastCommonNode(list<TreeNode*> tree_listx, list<TreeNode*> tree_listy)

{

list<TreeNode*>::iterator iter1 = tree_listx.begin();

list<TreeNode*>::iterator iter2 = tree_listy.begin();

TreeNode* pResult = NULL;

while (iter1!=tree_listx.end()&&iter2!=tree_listy.end())

{

if (*iter1 == *iter2)

pResult = *iter1;

iter1++;

iter2++;

}

return pResult;

}

TreeNode* FindCommonGrand(TreeNode* pRoot, TreeNode* pNodex, TreeNode* pNodey)

{

if (pRoot == NULL || pNodex == NULL || pNodey == NULL)

return NULL;

list<TreeNode*> tree_listx;

FindPath(pRoot, pNodex,tree_listx);

list<TreeNode*> tree_listy;

FindPath(pRoot, pNodey, tree_listy);

return GetLastCommonNode(tree_listx, tree_listy);

}

int main()

{

TreeNode* pNode1=CreatTreeNode(1);

TreeNode* pNode2 = CreatTreeNode(2);

TreeNode* pNode3 = CreatTreeNode(3);

TreeNode* pNode4 = CreatTreeNode(4);

TreeNode* pNode5 = CreatTreeNode(5);

TreeNode* pNode6 = CreatTreeNode(6);

TreeNode* pNode7 = CreatTreeNode(7);

TreeNode *pNode8 = CreatTreeNode(8);

TreeNode *pNode9 = CreatTreeNode(9);

TreeNode *pNode10 = CreatTreeNode(10);

ConnectTreeNode(pNode1, pNode2);

ConnectTreeNode(pNode1, pNode3);

ConnectTreeNode(pNode2, pNode4);

ConnectTreeNode(pNode2, pNode5);

ConnectTreeNode(pNode4, pNode6);

ConnectTreeNode(pNode4, pNode7);

ConnectTreeNode(pNode5, pNode8);

ConnectTreeNode(pNode5, pNode9);

ConnectTreeNode(pNode5, pNode10);

TreeNode* pRoot = pNode1;

PrintTree(pRoot);

TreeNode* pNodex = pNode7;

TreeNode* pNodey = pNode9;

TreeNode* pRes=FindCommonGrand(pRoot, pNodex, pNodey);

cout << “最近公共节点:” << pRes->val << endl;

system(“pause”);

return 0;

}

/////////////////文件tree.h

#ifndef TREE_H
#define TREE_H

#include <vector>
#include <iostream>
using namespace std;
struct TreeNode
{
int val;
vector<TreeNode*> m_children;
};

TreeNode* CreatTreeNode(int);
void ConnectTreeNode(TreeNode* pParent, TreeNode* pChild);
void PrintTreeNode(TreeNode* pNode);
void PrintTree(TreeNode* pRoot);
#endif

/////////////////文件tree.cc

#include “tree.h”

TreeNode* CreatTreeNode(int val)
{
TreeNode* pNode = new TreeNode();
pNode->val = val;
return pNode;
}
void ConnectTreeNode(TreeNode* pParent, TreeNode* pChild)
{
if (pParent!=NULL)
{
pParent->m_children.push_back(pChild);
}
}
void PrintTreeNode(TreeNode* pNode)
{
if (pNode != NULL)
{
cout << “树是:” <<pNode->val<<endl;
if (pNode->m_children.empty())
{
cout << “树没有子节点！”;
}
else
{
cout << “树的子节点是：”;
vector<TreeNode*>::iterator iter = pNode->m_children.begin();
while (iter != pNode->m_children.end())
{
if (*iter != NULL)
cout << (*iter)->val << “,”;
iter++;
}
}
cout << endl;
}
else
cout << “树是空的” << endl;
}
void PrintTree(TreeNode* pRoot)
{
PrintTreeNode(pRoot);
if (pRoot!=NULL)
{
vector<TreeNode*>::iterator iter = pRoot->m_children.begin();
while (iter!=pRoot->m_children.end())
{
PrintTree(*iter);
iter++;
}
}
}