LCA（Least Common Ancestors）最近公共祖先

LCA（Least Common Ancestors），即最近公共祖先，是指这样一个问题：在有根树中，找出某两个结点u和v最近的公共祖先（另一种说法，离树根最远的公共祖先）。

对于该问题，最容易想到的算法是分别从节点u和v回溯到根节点，获取u和v到根节点的路径P1，P2，其中P1和P2可以看成两条单链表，这就转换成常见的一道面试题：【判断两个单链表是否相交，如果相交，给出相交的第一个点。】。该算法总的复杂度是O（n）（其中n是树节点个数）。



构建上面这个树，求节点F和节点H的最近公共祖先

<pre name="code" class="cpp">#include <stdio.h>
#include <stdlib.h>

struct TreeNode {
char element;
struct TreeNode **child;
unsigned int child_num;
};
typedef struct TreeNode * Tree_t;
struct PathNode {
char element;
struct PathNode * next;
};
typedef struct PathNode * Path_list;
Tree_t g_tree;

Path_list dsf(Tree_t tree,Path_list path,char element) {
unsigned int i;
Tree_t tmp;
Path_list tmp_path;
if(NULL == tree)
return;
//printf("Element is %d\n",tree->element);
tmp_path = (Path_list)malloc(sizeof(struct PathNode));
if(tmp_path == NULL) {
printf("malloc path list error\n");
exit(-1);
}
tmp_path->next = NULL;
tmp_path->element = tree->element;
if(path != NULL) {
path->next = tmp_path;
}else {
path = tmp_path;
}
if(tree->element == element) {
return path;
}
for(i = 0; i < tree->child_num;i++) {
tmp = tree->child[i];
if(NULL != dsf(tmp,tmp_path,element))
return tmp_path;
free(tmp_path->next);
tmp_path->next = NULL;
}
return NULL;
}

void main(int argc, char *argv[])
{
unsigned int i;
Tree_t tree;
Tree_t next_tree;
Path_list path_a,path_b;
char common_node = 255;

g_tree = (Tree_t)malloc(sizeof(struct TreeNode));
if(g_tree == NULL) {
printf("g_tree malloc error\n");
return;
}
g_tree->element = 'A';
g_tree->child_num = 2;

g_tree->child = (Tree_t *)malloc(sizeof(Tree_t));
for(i = 0; i < 2; i++) {
g_tree->child[i] = (Tree_t)malloc(sizeof(struct TreeNode));
if(g_tree->child[i] == NULL) {
printf("malloc g_tree child error\n");
exit(-1);
}
}
g_tree->child[0]->element = 'B';
g_tree->child[0]->child_num = 2;
g_tree->child[1]->element = 'C';
g_tree->child[1]->child_num = 0;
g_tree->child[1]->child = NULL;

tree = g_tree->child[0];
tree->child = (Tree_t *)malloc(sizeof(Tree_t)*2);
for(i = 0; i < 2;i++) {
tree->child[i] = (Tree_t)malloc(sizeof(struct TreeNode));
if(tree->child[i] == NULL) {
printf("malloc tree child error\n");
exit(-1);
}
}
tree->child[0]->element = 'D';
tree->child[0]->child_num = 2;

tree->child[1]->element = 'E';
tree->child[1]->child_num = 3;

next_tree = tree->child[0];
next_tree->child = (Tree_t *)malloc(sizeof(Tree_t)*2);
for(i = 0; i < 2;i++) {
next_tree->child[i] = (Tree_t)malloc(sizeof(struct TreeNode));
if(next_tree->child[i] == NULL) {
printf("malloc next tree child error\n");
exit(-1);
}
}
next_tree->child[0]->element = 'F';
next_tree->child[0]->child_num = 0;
next_tree->child[1]->element = 'G';
next_tree->child[1]->child_num = 0;

next_tree = tree->child[1];
next_tree->child = (Tree_t *)malloc(sizeof(Tree_t)*3);
for(i = 0; i < 3;i++) {
next_tree->child[i] = (Tree_t)malloc(sizeof(struct TreeNode));
if(next_tree->child[i] == NULL) {
printf("malloc next tree child error\n");
exit(-1);
}
}

next_tree->child[0]->element = 'H';
next_tree->child[0]->child_num = 0;
next_tree->child[1]->element = 'I';
next_tree->child[1]->child_num = 0;
next_tree->child[2]->element = 'J';
next_tree->child[2]->child_num = 0;

path_a = NULL;
path_b = NULL;

path_a = dsf(g_tree,path_a,'F');
path_b = dsf(g_tree,path_b,'H');

while(path_a && path_b && (path_a->element == path_b->element)) {
common_node = path_a->element;
path_a = path_a->next;
path_b = path_b->next;
}

if(common_node != 255) {
printf("find LCA node %c\n",common_node);
}else {
printf("no LCA node\n");
}
return ;
}