用双亲表示法存储的树，如何找最近共同父结点，高分相送

[数据出境研究所]

#define MAX_TREE_SIZE 100

typedef struct

{

TElemType data;

int parent; /* 双亲位置域 */

} PTNode;

typedef struct

{

PTNode nodes[MAX_TREE_SIZE];

int n; /* 结点数 */

} PTree;


用双亲表示法存储的树，如何找任意两个节点的最近共同父结点，高手们指点一下，最好有代码，非常感谢

[acdbxzyw]

最小公共祖先。
这个。。。还是搜搜吧。

[showjim]

先找到根节点，确定各自的深度，然后：
如果可以用空间换时间，则在找根节点的时间记录各自的双亲节点序列，然后找到第一个同级不同值的节点。
如果节省空间，先找到较深节点与较浅节点同级的节点，然后找到第一个值相同的节点。

[abcdef0966]

双亲法表示的LCA问题，比较简单吧

PTNode PTLCA(PTNode A, PTNode B, PTree T)
{
	int Aa_index = A.parent;
	int Ba_index = B.parent;
	while ( Aa_index != Ba_index)
	{
		PTNode AaNode,BaNode;
		AaNode = PTree.nodes[Aa.index];
		BaNode = PTree.nodes[Ba.index];
		Aa.index = AaNode.parent;
		Ba.index = BaNode.parent;
	}
	return PTree.nodes[Aa.index];
}

[oyzdz1988]

不是这么简单的吧，下面的做法是错误的，下面的只适合两节点在同一层的情况。。。
[Quote=引用 3 楼 abcdef0966 的回复:]
双亲法表示的LCA问题，比较简单吧


C/C++ codePTNode PTLCA(PTNode A, PTNode B, PTree T)
{int Aa_index= A.parent;int Ba_index= B.parent;while ( Aa_index!= Ba_index)
{
PTNode AaNode,BaNode;
AaNode= PTree.nodes[Aa.index];
BaNode= PTree.nodes[Ba.index];
Aa.index= AaNode.parent;
Ba.index= BaNode.parent;
}return PTree.nodes[Aa.index];
}
[/Quote]

[linren]

可以维护一个结点(b)的路径

每次把当前位置改为上一次的两个结点的父节点位置
然后判断结点(a)是否在结点(b)的路径中

不过有些情况需要仔细的考虑
比如说两个结点为同一结点
一个结点正好是另一个结点的父节点或祖先结点等等（可以把当前结点b也放入路径当中）……

[linren]

[Quote=引用 5 楼 linren 的回复:]
每次把当前位置改为上一次的两个结点的父节点位置
然后判断结点(a)是否在结点(b)的路径中
[/Quote]
在进行下一次的判断时
把结点b经过的新结点加入到维护的路径当中

[黄舒颖 咸丫蛋]

这种方法思想是正确的。
实现的话。

把 b->rootb 路径上的所有结点用哈希表存储起来。

然后对 a -> roota 上每一个点 进行判断，
如果有一个节点在哈希表中，则说明该点是二者最近共同父节点



[Quote=引用 5 楼 linren 的回复:]
可以维护一个结点(b)的路径

每次把当前位置改为上一次的两个结点的父节点位置
然后判断结点(a)是否在结点(b)的路径中

不过有些情况需要仔细的考虑
比如说两个结点为同一结点
一个结点正好是另一个结点的父节点或祖先结点等等（可以把当前结点b也放入路径当中）……
[/Quote]

[linren]

（上接5楼）

【程序】

#include <stdio.h>
#include <stdlib.h>
#define MAX_TREE_SIZE 100 

typedef int TElemType;

typedef struct
{
	TElemType data;
	int parent; /* 双亲位置域 */
}PTNode;

typedef struct 
{
	PTNode nodes[MAX_TREE_SIZE];
	int n; /* 结点数 */
}PTree;


int find(PTree* nds,int node1,int node2){
	PTNode a,b;
	int i,k;
	int* n2path;

	if(node1==node2) return node1;
	a=nds->nodes[node1];
	b=nds->nodes[node2];
	if(a.parent==node2||node2==0) return node2;
	if(b.parent==node1||node1==0) return node1;

	n2path=(int*)malloc(sizeof(int)*nds->n);
	k=0;n2path[k]=node2;
	k++;n2path[k]=b.parent;
	while(b.parent!=0){
		b=nds->nodes[b.parent];
		k++;n2path[k]=b.parent;
	}
	while(1){
		for(i=0;i<=k;i++){
			if(a.parent==n2path[i]){
				free(n2path);return a.parent;
			}
		}
		a=nds->nodes[a.parent];
	}
}

int main(){
	PTree t;
	t.n=9;
	t.nodes[0].parent=0;
	t.nodes[1].parent=0;
	t.nodes[2].parent=0;
	t.nodes[3].parent=1;
	t.nodes[4].parent=1;
	t.nodes[5].parent=2;
	t.nodes[6].parent=2;
	t.nodes[7].parent=3;
	t.nodes[8].parent=3;

	printf("%d\n",find(&t,7,4));

    return 0;
}

【运行结果】
1
Press any key to continue

[linren]

[Quote=引用 7 楼 vshuang 的回复:]
这种方法思想是正确的。
实现的话。

把 b->rootb 路径上的所有结点用哈希表存储起来。

然后对 a -> roota 上每一个点 进行判断，
如果有一个节点在哈希表中，则说明该点是二者最近共同父节点

[/Quote]
恩
如果用哈希表的话效率会好很多……

8楼的程序的时间复杂度大概是m*n
其中m为node2的深度
n为node1的深度……

[qq675927952]

up LS

[bigc2000]

(1)都走到根,比记录序列设为A,B
(2)对这2个序列选择最短的那个 假设是A
对A中的元素(这里选择反方向,即第一个是根)在B中查找,直到找不到,那么上一个元素就是最近的公共根

复杂度可以看成是O(m+n+mlogn)

[bigc2000]

写错了

应该是O(m+n)

最后查找 应该是O(min(m,n))
查找的方法即反向同位比较序列,如果不同,则上一个是共同根

[FancyMouse]

单次询问的话记录层深然后再往上走没问题
询问很多还是tarjan吧

[linren]

【程序】

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_TREE_SIZE 100 

typedef int TElemType;

typedef struct
{
    TElemType data;
    int parent; /* 双亲位置域 */
}PTNode;

typedef struct 
{
    PTNode nodes[MAX_TREE_SIZE];
    int n; /* 结点数 */
}PTree;


int find(PTree* nds,int node1,int node2){
    PTNode a,b;
    char* n2path;
	int p;

    if(node1==node2) return node1;
    a=nds->nodes[node1];
    b=nds->nodes[node2];
    if(a.parent==node2||node2==0) return node2;
    if(b.parent==node1||node1==0) return node1;

    n2path=(char*)malloc(sizeof(char)*MAX_TREE_SIZE);
	memset(n2path,0,sizeof(char)*MAX_TREE_SIZE);
    n2path[node2]=1;
    n2path[b.parent]=1;
    while(b.parent!=0){
        b=nds->nodes[b.parent];
        n2path[b.parent]=1;
    }
	p=node1;
    while(1){
        if(n2path[p]==1){
            free(n2path);return p;
        }
		p=a.parent;
        a=nds->nodes[a.parent];
    }
}

int main(){
    PTree t;
	int i,j;
    t.n=9;
    t.nodes[0].parent=0;
    t.nodes[1].parent=0;
    t.nodes[2].parent=0;
    t.nodes[3].parent=1;
    t.nodes[4].parent=1;
    t.nodes[5].parent=2;
    t.nodes[6].parent=2;
    t.nodes[7].parent=3;
    t.nodes[8].parent=3;

    for(i=0;i<9;i++) for(j=0;j<9;j++) printf("%d,%d=>%d\n",i,j,find(&t,i,j));

    return 0;
}

【运行结果】
0,0=>0
0,1=>0
0,2=>0
0,3=>0
0,4=>0
0,5=>0
0,6=>0
0,7=>0
0,8=>0
1,0=>0
1,1=>1
1,2=>0
1,3=>1
1,4=>1
1,5=>0
1,6=>0
1,7=>1
1,8=>1
2,0=>0
2,1=>0
2,2=>2
2,3=>0
2,4=>0
2,5=>2
2,6=>2
2,7=>0
2,8=>0
3,0=>0
3,1=>1
3,2=>0
3,3=>3
3,4=>1
3,5=>0
3,6=>0
3,7=>3
3,8=>3
4,0=>0
4,1=>1
4,2=>0
4,3=>1
4,4=>4
4,5=>0
4,6=>0
4,7=>1
4,8=>1
5,0=>0
5,1=>0
5,2=>2
5,3=>0
5,4=>0
5,5=>5
5,6=>2
5,7=>0
5,8=>0
6,0=>0
6,1=>0
6,2=>2
6,3=>0
6,4=>0
6,5=>2
6,6=>6
6,7=>0
6,8=>0
7,0=>0
7,1=>1
7,2=>0
7,3=>3
7,4=>1
7,5=>0
7,6=>0
7,7=>7
7,8=>3
8,0=>0
8,1=>1
8,2=>0
8,3=>3
8,4=>1
8,5=>0
8,6=>0
8,7=>3
8,8=>8
Press any key to continue

【说明】
8楼的程序有一个问题
忘记判断node1本身了……

这个新的程序是用空间换时间的一种办法
时间复杂度为m+n……

[urakvv7]

[Quote=引用 12 楼 bigc2000 的回复:]
写错了

应该是O(m+n)

最后查找 应该是O(min(m,n))
查找的方法即反向同位比较序列,如果不同,则上一个是共同根
[/Quote]

没有必要都走到根。
只记录一个序列，并将其信息存到哈希表中。
在另一个节点向根走的时候同时判断当前节点是否在哈希表中存在。
最坏情况下时间复杂度为m+n。
这实际上是vshuang的思路;-)