Java数据结构之并查集的实现

Java数据结构之并查集的实现

目录代码解析代码应用实际应用

并查集就是将原本不在一个集合里面的内容合并到一个集合中。

在实际的场景中用处不多。

除了出现在你需要同时去几个集合里面查询，避免出现查询很多次，从而放在一起查询的情况。

下面简单实现一个例子，我们来举例说明一下什么是并查集，以及究竟并查集解决了什么问题。

代码解析

package com.chaojilaji.book.andcheck;

public class AndCheckSet {

public static Integer getFather(int[] father, int u) {

if (father[u] != u) {

father[u] = getFather(father, father[u]);

}

return father[u];

}

public static void join(int[] father,int x, int y) {

int fx = getFather(father,x);

http:// int fy = getFather(father,y);

if (fx != fy){

father[fx] = fy;

}

}

public static void main(String[] args) {

int n = 10;

int[] a = new int[n];

for (int i = 0;i

a[i] = i; // 初始化定义一百个集合

}

for (int i=0;i

System.out.println(i+" "+getFather(a, i)); // 对于每个集合，父节点都是自己

}

}

}

首先，我们定义了两个函数，分别为getFather和join，分别表示获取u所在集合的根以及合并两个集合。

先来看看gethttp://Father方法

public static Integer getFather(int[] father, int u) {

if (father[u] != u) {

father[u] = getFather(father, father[u]);

}

return father[u];

}

是找出值u所在集合的根节点是多少。一般来说，father[u]如果等于u本身，那么说明u所在节点就是根节点，而这个算法是直到相等才退出，也就是说，对于从u到根节点的每个节点的father都被直接置为根节点，同时返回了当前节点的根节点。

然后来看看join方法

public static void join(int[] father,int x, int y) {

int fx = getFather(father,x);

int fy = getFather(father,y);

if (fx != fy){

father[fx] = fy;

}

}

分别找出x和y两个节点所在集合的根节点，如果根节点不一样，则将其中一个节点的father节点置为另一个节点即可，这样就合并成了一个集合。

代码应用

public static void main(String[] args) {

int n = 10;

int[] a = new int[n];

for (int i = 0;i

a[i] = i; // 初始化定义n个集合

}

for (int i=0;i

System.out.println(i+" "+getFather(a, i)); // 对于每个集合，父节点都是自己

}

System.out.println("-------------------------");

join(a,0,1); // 合并 0 和 1

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了0和1，所以集合变成了9个，节点0和节点1的根都是节点1

System.out.println("-------------------------");

join(a,2,3); // 合并 2 和 3

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了2和3，所以集合变成8个，节点2和节点3的根都是节点3

System.out.println("-------------------------");

join(a,1,3); // 合并 1 和 3

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了1和3，所以集合变成7个，节点0,1,2,3的根都是节点3

}

首先，我们定义了n个集合，这n个集合的值是0~n-1，然后此时他们的父节点均等于他们本身，所以这就是n个独立的集合，结果如下

0的父节点为 0 1的父节点为 1 2的父节点为 2 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点为 8 9的父节点为 9

然后调用 join(a,0,1)合并0集合和1集合，再输出节点父集合情况为

0的父节点为 1 1的父节点为 1 2的父节点为 2 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 http://7的父节点为 7 8的父节点为 8 9的父节点为 9

可以看见，由于合并了0和1，所以集合变成了9个，节点0和节点1的根都是节点1。然后调用 join(a,2,3) 合并2集合和3集合，输出节点父集合情况为

0的父节点为 1 1的父节点为 1 2的父节点为 3 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点为 8 9的父节点为 9

可以看见，由于合并了2和3，所以集合变成8个，节点2和节点3的根都是节点3。最后，我们再调用join(a,1,3) 合并1集合和3集合，输出节点父集合情况为

0的父节点为 3 1的父节点为 3 2的父节点为 3 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点cocPrGxa为 8 9的父节点为 9

可以看出来，由于合并了1和3，所以集合变成7个，节点0,1,2,3的根都是节点3。

实际应用

代码的层面来讲，并查集很好实现。但是我们却也可以发现，其应用场景似乎非常局限。首先，我们需要定义出一个father[x] = x的数组，然后我们再去合并。似乎很难想到应用场景。

那么我们可以想象一个场景，现在有个网络拓扑图，里面有n和网络设施设备，然后又给了你这n个设施设备之间的连接关系，问你一共有多少个局部联通网。对于这个问题，我们就可以首先定义每个设备自己跟自己相连，然后每出现一条边，就对这两个设备采取join操作。最终我们在遍历完所有的节点，得到多少个不同的father，即表示有多少个不同的局部联通网。

这样的问题还可以延伸到我们的人际交友圈，首先每个人都是单独的集合，在不断认识人的过程中，产生连通性。最终让你确认一共有多少个不互通的人际圈。

所以你会发现，这本质上就是求图论中连通块的个数。

a[i] = i; // 初始化定义一百个集合

}

for (int i=0;i

System.out.println(i+" "+getFather(a, i)); // 对于每个集合，父节点都是自己

}

}

}

首先，我们定义了两个函数，分别为getFather和join，分别表示获取u所在集合的根以及合并两个集合。

先来看看gethttp://Father方法

public static Integer getFather(int[] father, int u) {

if (father[u] != u) {

father[u] = getFather(father, father[u]);

}

return father[u];

}

是找出值u所在集合的根节点是多少。一般来说，father[u]如果等于u本身，那么说明u所在节点就是根节点，而这个算法是直到相等才退出，也就是说，对于从u到根节点的每个节点的father都被直接置为根节点，同时返回了当前节点的根节点。

然后来看看join方法

public static void join(int[] father,int x, int y) {

int fx = getFather(father,x);

int fy = getFather(father,y);

if (fx != fy){

father[fx] = fy;

}

}

分别找出x和y两个节点所在集合的根节点，如果根节点不一样，则将其中一个节点的father节点置为另一个节点即可，这样就合并成了一个集合。

代码应用

public static void main(String[] args) {

int n = 10;

int[] a = new int[n];

for (int i = 0;i

a[i] = i; // 初始化定义n个集合

}

for (int i=0;i

System.out.println(i+" "+getFather(a, i)); // 对于每个集合，父节点都是自己

}

System.out.println("-------------------------");

join(a,0,1); // 合并 0 和 1

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了0和1，所以集合变成了9个，节点0和节点1的根都是节点1

System.out.println("-------------------------");

join(a,2,3); // 合并 2 和 3

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了2和3，所以集合变成8个，节点2和节点3的根都是节点3

System.out.println("-------------------------");

join(a,1,3); // 合并 1 和 3

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了1和3，所以集合变成7个，节点0,1,2,3的根都是节点3

}

首先，我们定义了n个集合，这n个集合的值是0~n-1，然后此时他们的父节点均等于他们本身，所以这就是n个独立的集合，结果如下

0的父节点为 0 1的父节点为 1 2的父节点为 2 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点为 8 9的父节点为 9

然后调用 join(a,0,1)合并0集合和1集合，再输出节点父集合情况为

0的父节点为 1 1的父节点为 1 2的父节点为 2 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 http://7的父节点为 7 8的父节点为 8 9的父节点为 9

可以看见，由于合并了0和1，所以集合变成了9个，节点0和节点1的根都是节点1。然后调用 join(a,2,3) 合并2集合和3集合，输出节点父集合情况为

0的父节点为 1 1的父节点为 1 2的父节点为 3 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点为 8 9的父节点为 9

可以看见，由于合并了2和3，所以集合变成8个，节点2和节点3的根都是节点3。最后，我们再调用join(a,1,3) 合并1集合和3集合，输出节点父集合情况为

0的父节点为 3 1的父节点为 3 2的父节点为 3 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点cocPrGxa为 8 9的父节点为 9

可以看出来，由于合并了1和3，所以集合变成7个，节点0,1,2,3的根都是节点3。

实际应用

代码的层面来讲，并查集很好实现。但是我们却也可以发现，其应用场景似乎非常局限。首先，我们需要定义出一个father[x] = x的数组，然后我们再去合并。似乎很难想到应用场景。

那么我们可以想象一个场景，现在有个网络拓扑图，里面有n和网络设施设备，然后又给了你这n个设施设备之间的连接关系，问你一共有多少个局部联通网。对于这个问题，我们就可以首先定义每个设备自己跟自己相连，然后每出现一条边，就对这两个设备采取join操作。最终我们在遍历完所有的节点，得到多少个不同的father，即表示有多少个不同的局部联通网。

这样的问题还可以延伸到我们的人际交友圈，首先每个人都是单独的集合，在不断认识人的过程中，产生连通性。最终让你确认一共有多少个不互通的人际圈。

所以你会发现，这本质上就是求图论中连通块的个数。

System.out.println(i+" "+getFather(a, i)); // 对于每个集合，父节点都是自己

}

}

}

首先，我们定义了两个函数，分别为getFather和join，分别表示获取u所在集合的根以及合并两个集合。

先来看看gethttp://Father方法

public static Integer getFather(int[] father, int u) {

if (father[u] != u) {

father[u] = getFather(father, father[u]);

}

return father[u];

}

是找出值u所在集合的根节点是多少。一般来说，father[u]如果等于u本身，那么说明u所在节点就是根节点，而这个算法是直到相等才退出，也就是说，对于从u到根节点的每个节点的father都被直接置为根节点，同时返回了当前节点的根节点。

然后来看看join方法

public static void join(int[] father,int x, int y) {

int fx = getFather(father,x);

int fy = getFather(father,y);

if (fx != fy){

father[fx] = fy;

}

}

分别找出x和y两个节点所在集合的根节点，如果根节点不一样，则将其中一个节点的father节点置为另一个节点即可，这样就合并成了一个集合。

代码应用

public static void main(String[] args) {

int n = 10;

int[] a = new int[n];

for (int i = 0;i

a[i] = i; // 初始化定义n个集合

}

for (int i=0;i

System.out.println(i+" "+getFather(a, i)); // 对于每个集合，父节点都是自己

}

System.out.println("-------------------------");

join(a,0,1); // 合并 0 和 1

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了0和1，所以集合变成了9个，节点0和节点1的根都是节点1

System.out.println("-------------------------");

join(a,2,3); // 合并 2 和 3

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了2和3，所以集合变成8个，节点2和节点3的根都是节点3

System.out.println("-------------------------");

join(a,1,3); // 合并 1 和 3

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了1和3，所以集合变成7个，节点0,1,2,3的根都是节点3

}

首先，我们定义了n个集合，这n个集合的值是0~n-1，然后此时他们的父节点均等于他们本身，所以这就是n个独立的集合，结果如下

0的父节点为 0 1的父节点为 1 2的父节点为 2 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点为 8 9的父节点为 9

然后调用 join(a,0,1)合并0集合和1集合，再输出节点父集合情况为

0的父节点为 1 1的父节点为 1 2的父节点为 2 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 http://7的父节点为 7 8的父节点为 8 9的父节点为 9

可以看见，由于合并了0和1，所以集合变成了9个，节点0和节点1的根都是节点1。然后调用 join(a,2,3) 合并2集合和3集合，输出节点父集合情况为

0的父节点为 1 1的父节点为 1 2的父节点为 3 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点为 8 9的父节点为 9

可以看见，由于合并了2和3，所以集合变成8个，节点2和节点3的根都是节点3。最后，我们再调用join(a,1,3) 合并1集合和3集合，输出节点父集合情况为

0的父节点为 3 1的父节点为 3 2的父节点为 3 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点cocPrGxa为 8 9的父节点为 9

可以看出来，由于合并了1和3，所以集合变成7个，节点0,1,2,3的根都是节点3。

实际应用

代码的层面来讲，并查集很好实现。但是我们却也可以发现，其应用场景似乎非常局限。首先，我们需要定义出一个father[x] = x的数组，然后我们再去合并。似乎很难想到应用场景。

那么我们可以想象一个场景，现在有个网络拓扑图，里面有n和网络设施设备，然后又给了你这n个设施设备之间的连接关系，问你一共有多少个局部联通网。对于这个问题，我们就可以首先定义每个设备自己跟自己相连，然后每出现一条边，就对这两个设备采取join操作。最终我们在遍历完所有的节点，得到多少个不同的father，即表示有多少个不同的局部联通网。

这样的问题还可以延伸到我们的人际交友圈，首先每个人都是单独的集合，在不断认识人的过程中，产生连通性。最终让你确认一共有多少个不互通的人际圈。

所以你会发现，这本质上就是求图论中连通块的个数。

a[i] = i; // 初始化定义n个集合

}

for (int i=0;i

System.out.println(i+" "+getFather(a, i)); // 对于每个集合，父节点都是自己

}

System.out.println("-------------------------");

join(a,0,1); // 合并 0 和 1

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了0和1，所以集合变成了9个，节点0和节点1的根都是节点1

System.out.println("-------------------------");

join(a,2,3); // 合并 2 和 3

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了2和3，所以集合变成8个，节点2和节点3的根都是节点3

System.out.println("-------------------------");

join(a,1,3); // 合并 1 和 3

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了1和3，所以集合变成7个，节点0,1,2,3的根都是节点3

}

首先，我们定义了n个集合，这n个集合的值是0~n-1，然后此时他们的父节点均等于他们本身，所以这就是n个独立的集合，结果如下

0的父节点为 0 1的父节点为 1 2的父节点为 2 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点为 8 9的父节点为 9

然后调用 join(a,0,1)合并0集合和1集合，再输出节点父集合情况为

0的父节点为 1 1的父节点为 1 2的父节点为 2 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 http://7的父节点为 7 8的父节点为 8 9的父节点为 9

可以看见，由于合并了0和1，所以集合变成了9个，节点0和节点1的根都是节点1。然后调用 join(a,2,3) 合并2集合和3集合，输出节点父集合情况为

0的父节点为 1 1的父节点为 1 2的父节点为 3 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点为 8 9的父节点为 9

可以看见，由于合并了2和3，所以集合变成8个，节点2和节点3的根都是节点3。最后，我们再调用join(a,1,3) 合并1集合和3集合，输出节点父集合情况为

0的父节点为 3 1的父节点为 3 2的父节点为 3 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点cocPrGxa为 8 9的父节点为 9

可以看出来，由于合并了1和3，所以集合变成7个，节点0,1,2,3的根都是节点3。

实际应用

代码的层面来讲，并查集很好实现。但是我们却也可以发现，其应用场景似乎非常局限。首先，我们需要定义出一个father[x] = x的数组，然后我们再去合并。似乎很难想到应用场景。

那么我们可以想象一个场景，现在有个网络拓扑图，里面有n和网络设施设备，然后又给了你这n个设施设备之间的连接关系，问你一共有多少个局部联通网。对于这个问题，我们就可以首先定义每个设备自己跟自己相连，然后每出现一条边，就对这两个设备采取join操作。最终我们在遍历完所有的节点，得到多少个不同的father，即表示有多少个不同的局部联通网。

这样的问题还可以延伸到我们的人际交友圈，首先每个人都是单独的集合，在不断认识人的过程中，产生连通性。最终让你确认一共有多少个不互通的人际圈。

所以你会发现，这本质上就是求图论中连通块的个数。

System.out.println(i+" "+getFather(a, i)); // 对于每个集合，父节点都是自己

}

System.out.println("-------------------------");

join(a,0,1); // 合并 0 和 1

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了0和1，所以集合变成了9个，节点0和节点1的根都是节点1

System.out.println("-------------------------");

join(a,2,3); // 合并 2 和 3

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了2和3，所以集合变成8个，节点2和节点3的根都是节点3

System.out.println("-------------------------");

join(a,1,3); // 合并 1 和 3

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了1和3，所以集合变成7个，节点0,1,2,3的根都是节点3

}

首先，我们定义了n个集合，这n个集合的值是0~n-1，然后此时他们的父节点均等于他们本身，所以这就是n个独立的集合，结果如下

0的父节点为 0 1的父节点为 1 2的父节点为 2 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点为 8 9的父节点为 9

然后调用 join(a,0,1)合并0集合和1集合，再输出节点父集合情况为

0的父节点为 1 1的父节点为 1 2的父节点为 2 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 http://7的父节点为 7 8的父节点为 8 9的父节点为 9

可以看见，由于合并了0和1，所以集合变成了9个，节点0和节点1的根都是节点1。然后调用 join(a,2,3) 合并2集合和3集合，输出节点父集合情况为

0的父节点为 1 1的父节点为 1 2的父节点为 3 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点为 8 9的父节点为 9

可以看见，由于合并了2和3，所以集合变成8个，节点2和节点3的根都是节点3。最后，我们再调用join(a,1,3) 合并1集合和3集合，输出节点父集合情况为

0的父节点为 3 1的父节点为 3 2的父节点为 3 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点cocPrGxa为 8 9的父节点为 9

可以看出来，由于合并了1和3，所以集合变成7个，节点0,1,2,3的根都是节点3。

实际应用

代码的层面来讲，并查集很好实现。但是我们却也可以发现，其应用场景似乎非常局限。首先，我们需要定义出一个father[x] = x的数组，然后我们再去合并。似乎很难想到应用场景。

那么我们可以想象一个场景，现在有个网络拓扑图，里面有n和网络设施设备，然后又给了你这n个设施设备之间的连接关系，问你一共有多少个局部联通网。对于这个问题，我们就可以首先定义每个设备自己跟自己相连，然后每出现一条边，就对这两个设备采取join操作。最终我们在遍历完所有的节点，得到多少个不同的father，即表示有多少个不同的局部联通网。

这样的问题还可以延伸到我们的人际交友圈，首先每个人都是单独的集合，在不断认识人的过程中，产生连通性。最终让你确认一共有多少个不互通的人际圈。

所以你会发现，这本质上就是求图论中连通块的个数。

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了0和1，所以集合变成了9个，节点0和节点1的根都是节点1

System.out.println("-------------------------");

join(a,2,3); // 合并 2 和 3

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了2和3，所以集合变成8个，节点2和节点3的根都是节点3

System.out.println("-------------------------");

join(a,1,3); // 合并 1 和 3

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了1和3，所以集合变成7个，节点0,1,2,3的根都是节点3

}

首先，我们定义了n个集合，这n个集合的值是0~n-1，然后此时他们的父节点均等于他们本身，所以这就是n个独立的集合，结果如下

0的父节点为 0 1的父节点为 1 2的父节点为 2 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点为 8 9的父节点为 9

然后调用 join(a,0,1)合并0集合和1集合，再输出节点父集合情况为

0的父节点为 1 1的父节点为 1 2的父节点为 2 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 http://7的父节点为 7 8的父节点为 8 9的父节点为 9

可以看见，由于合并了0和1，所以集合变成了9个，节点0和节点1的根都是节点1。然后调用 join(a,2,3) 合并2集合和3集合，输出节点父集合情况为

0的父节点为 1 1的父节点为 1 2的父节点为 3 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点为 8 9的父节点为 9

可以看见，由于合并了2和3，所以集合变成8个，节点2和节点3的根都是节点3。最后，我们再调用join(a,1,3) 合并1集合和3集合，输出节点父集合情况为

0的父节点为 3 1的父节点为 3 2的父节点为 3 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点cocPrGxa为 8 9的父节点为 9

可以看出来，由于合并了1和3，所以集合变成7个，节点0,1,2,3的根都是节点3。

实际应用

代码的层面来讲，并查集很好实现。但是我们却也可以发现，其应用场景似乎非常局限。首先，我们需要定义出一个father[x] = x的数组，然后我们再去合并。似乎很难想到应用场景。

那么我们可以想象一个场景，现在有个网络拓扑图，里面有n和网络设施设备，然后又给了你这n个设施设备之间的连接关系，问你一共有多少个局部联通网。对于这个问题，我们就可以首先定义每个设备自己跟自己相连，然后每出现一条边，就对这两个设备采取join操作。最终我们在遍历完所有的节点，得到多少个不同的father，即表示有多少个不同的局部联通网。

这样的问题还可以延伸到我们的人际交友圈，首先每个人都是单独的集合，在不断认识人的过程中，产生连通性。最终让你确认一共有多少个不互通的人际圈。

所以你会发现，这本质上就是求图论中连通块的个数。

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了2和3，所以集合变成8个，节点2和节点3的根都是节点3

System.out.println("-------------------------");

join(a,1,3); // 合并 1 和 3

for (int i=0;i

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了1和3，所以集合变成7个，节点0,1,2,3的根都是节点3

}

首先，我们定义了n个集合，这n个集合的值是0~n-1，然后此时他们的父节点均等于他们本身，所以这就是n个独立的集合，结果如下

0的父节点为 0 1的父节点为 1 2的父节点为 2 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点为 8 9的父节点为 9

然后调用 join(a,0,1)合并0集合和1集合，再输出节点父集合情况为

0的父节点为 1 1的父节点为 1 2的父节点为 2 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 http://7的父节点为 7 8的父节点为 8 9的父节点为 9

可以看见，由于合并了0和1，所以集合变成了9个，节点0和节点1的根都是节点1。然后调用 join(a,2,3) 合并2集合和3集合，输出节点父集合情况为

0的父节点为 1 1的父节点为 1 2的父节点为 3 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点为 8 9的父节点为 9

可以看见，由于合并了2和3，所以集合变成8个，节点2和节点3的根都是节点3。最后，我们再调用join(a,1,3) 合并1集合和3集合，输出节点父集合情况为

0的父节点为 3 1的父节点为 3 2的父节点为 3 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点cocPrGxa为 8 9的父节点为 9

可以看出来，由于合并了1和3，所以集合变成7个，节点0,1,2,3的根都是节点3。

实际应用

代码的层面来讲，并查集很好实现。但是我们却也可以发现，其应用场景似乎非常局限。首先，我们需要定义出一个father[x] = x的数组，然后我们再去合并。似乎很难想到应用场景。

那么我们可以想象一个场景，现在有个网络拓扑图，里面有n和网络设施设备，然后又给了你这n个设施设备之间的连接关系，问你一共有多少个局部联通网。对于这个问题，我们就可以首先定义每个设备自己跟自己相连，然后每出现一条边，就对这两个设备采取join操作。最终我们在遍历完所有的节点，得到多少个不同的father，即表示有多少个不同的局部联通网。

这样的问题还可以延伸到我们的人际交友圈，首先每个人都是单独的集合，在不断认识人的过程中，产生连通性。最终让你确认一共有多少个不互通的人际圈。

所以你会发现，这本质上就是求图论中连通块的个数。

System.out.println(i+" "+getFather(a, i));

}

// 由于合并了1和3，所以集合变成7个，节点0,1,2,3的根都是节点3

}

首先，我们定义了n个集合，这n个集合的值是0~n-1，然后此时他们的父节点均等于他们本身，所以这就是n个独立的集合，结果如下

0的父节点为 0 1的父节点为 1 2的父节点为 2 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点为 8 9的父节点为 9

然后调用 join(a,0,1)合并0集合和1集合，再输出节点父集合情况为

0的父节点为 1 1的父节点为 1 2的父节点为 2 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 http://7的父节点为 7 8的父节点为 8 9的父节点为 9

可以看见，由于合并了0和1，所以集合变成了9个，节点0和节点1的根都是节点1。然后调用 join(a,2,3) 合并2集合和3集合，输出节点父集合情况为

0的父节点为 1 1的父节点为 1 2的父节点为 3 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点为 8 9的父节点为 9

可以看见，由于合并了2和3，所以集合变成8个，节点2和节点3的根都是节点3。最后，我们再调用join(a,1,3) 合并1集合和3集合，输出节点父集合情况为

0的父节点为 3 1的父节点为 3 2的父节点为 3 3的父节点为 3 4的父节点为 4 5的父节点为 5 6的父节点为 6 7的父节点为 7 8的父节点cocPrGxa为 8 9的父节点为 9

可以看出来，由于合并了1和3，所以集合变成7个，节点0,1,2,3的根都是节点3。

实际应用

代码的层面来讲，并查集很好实现。但是我们却也可以发现，其应用场景似乎非常局限。首先，我们需要定义出一个father[x] = x的数组，然后我们再去合并。似乎很难想到应用场景。

那么我们可以想象一个场景，现在有个网络拓扑图，里面有n和网络设施设备，然后又给了你这n个设施设备之间的连接关系，问你一共有多少个局部联通网。对于这个问题，我们就可以首先定义每个设备自己跟自己相连，然后每出现一条边，就对这两个设备采取join操作。最终我们在遍历完所有的节点，得到多少个不同的father，即表示有多少个不同的局部联通网。

这样的问题还可以延伸到我们的人际交友圈，首先每个人都是单独的集合，在不断认识人的过程中，产生连通性。最终让你确认一共有多少个不互通的人际圈。

所以你会发现，这本质上就是求图论中连通块的个数。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。