并查集数据结构以及多机器解决岛屿数量问题

并查集能够解决的问题：

（1）查找两个元素是否处于同一个集合

（2）把两个集合合并。

并查集要求在建立并查集结构的时候，必须给出所有的并查集数据集，在之后的操作过程中不允许在动态添加数据。

我们先来看一张小图：

假设数据集如下：1，2，3，4，5，6

如果合并1和2，同时合并3，4，结果如下：

我们称1、3为代表节点，{1，2}、{3，4}、{5}、{6}是集合。现在合并{5}和{1，2}，就变成：

此时可以解决并查集的第二问题，查询4和1两个元素是否在同一个集合内，怎么做呢？就向上找代表节点，然后发现两个代表节点1和3不一样说明不在同一个集合内，现在合并{1，2，3}和{3，4}，如图：

代表节点为1了，如果此时查找4和2，是否在同一个集合内，就会发现最终找到的代表节点都是一样的，所以是true。同时查找节点以上都会变成这样：

查找结点的path路上每一个节点都会指向代表节点！

这就是并查集数据结构。再看它的应用：

（1）查找两个元素是否处于同一个集合

（2）把两个集合合并。

我们来看一下代码：

因为实际的排序啥的跟node内容是没有关系的，所以节点中可以是任意值：

    public static class Node{
        //可以是int、String、char
        //不需要指针
    }

基本数据结构：这里面是两个map集合，我们没有用链表这种方式，因为遍历的复杂度还是比较高的，用map可以保证O（1）,

fatherMap结构是存储了当前节点和它上一级节点，sizeMap是代表节点下面子节点的个数。初始化的时候，node的父节点指向的是自己。大小都是1，相当于每一个元素都是自己的集合代表节点。

    public static class UnionFindSet{
        //key => child，value => father
        public HashMap<Node,Node> fatherMap;
        //某个节点所在集合，有多少个
        public HashMap<Node,Integer> sizeMap;

        public UnionFindSet(List<Node> nodes){
            makeSets(nodes);
        }

        private void makeSets(List<Node> nodes){
            fatherMap = new HashMap<>();
            sizeMap = new HashMap<>();
            for(Node node :nodes){
                fatherMap.put(node,node);
                sizeMap.put(node,1);
            }
        }

这个方法是查找这个集合的代表节点，找到代表节点之后，依次返回到路上每一个节点的递归，然后设置每一个节点的父节点都指向代表节点。

        private Node findHead(Node node){
            Node  fatherNode = fatherMap.get(node);
            if(fatherNode != node){
                fatherNode = findHead(fatherNode);
            }
            fatherMap.put(node,fatherNode);
            return fatherNode;
        }

如果不喜欢递归，下面还有一个非递归版本的：

        private Node findHea1(Node node){
            Stack<Node> stack = new Stack<>();
            Node cur = node;
            Node parent = fatherMap.get(node);
            while(parent != node){
                stack.push(cur);
                cur = parent;
                parent = fatherMap.get(cur);
            }
            while(!stack.isEmpty()){
                fatherMap.put(stack.pop(),parent);
            }
            return parent;
        }

判断两个节点是否是同一个集合，就是找到代表节点，然后看代表节点是不是一致，这里面用==表示，只有内存地址或者引用一致的时候，才是相等。

        public boolean isSameSet(Node a,Node b){
            return findHead(a) == findHead(b);
        }

合并两个集合，首先拿到两个集合的节点，然后找到代表节点，拿出大小，然后在数量多的代表节点作为整个合并后集合的代表节点，然后更新信息，设置父节点，和大小

       public void union(Node a,Node b){
            if(a == null || b == null){
                return ;
            }
            Node aHead = findHead(a);
            Node bHead = findHead(b);
            if(aHead != bHead){
                int aSetSize = sizeMap.get(aHead);
                int bSetSize = sizeMap.get(bHead);
                if(aSetSize <= bSetSize){
                    fatherMap.put(aHead,bHead);
                    sizeMap.put(bHead,aSetSize + bSetSize);
                }else{
                    fatherMap.put(bHead,aHead);
                    sizeMap.put(aHead,aSetSize + bSetSize);
                }
            }
        }

so easy的并查集结构！！！

看一个小题：

岛问题

一个矩阵中只有0和1两种值，每个位置都可以和自己的上、下、左、右

四个位置相连，如果有一片1连在一起，这个部分叫做一个岛，求一个

矩阵中有多少个岛？

举例：

0 0 1 0 1 0

1 1 1 0 1 0

1 0 0 1 0 0

0 0 0 0 0 0

这个矩阵中有三个岛。

相信大家这道题都会了，利用感染的思想。具体解法可以看https://blog.csdn.net/weixin_44588495/article/details/106243644这里面由岛屿数量的解法。

我们现在说的是如果岛屿数据集庞大，一台机器解决很慢，我们需要多台机器如何解决？看下面的图

现在的岛屿：红色1代表陆地，白色的0代表海洋，用多台机器求现在岛屿有多少个，答案实际上上两个对吧。但是我们多台机器如何去算呢？

比如两台机器，分别计算左右两边：

多台机器难解决的问题在于计算完两边之后，如何合并呢？就是判断边界是否向相连。就像上面显示的，左边两个，右边两个，如果遇到一个边界-1，那么最后你会发现就剩一个岛屿了，实际上是不对的。所以，看如下解决：

（1）第一步：用之前的感染方法，求出每一个机器上面的岛屿数量，左边：2，右边：2。先相加一共是4个。

（2）对于左右两边每一个岛屿都用并查集，集合的代表节点就是起初的感染中心，比如看下图：

下面来看如何做：

现在有四个集合和他们分别的代表节点，我们开始比较边界信息，发现是否相连，发现可以连接。再判断是否是同一个集合，发现并不是。所以合并两个集合，总的岛屿数量-1。变成了3，下面的图变成了（这里面没画查询完都指向代表节点）：

然后比较相连元素，是不是同一个集合，是同一个集合，不操作。直接结束比较下一个。

比较是不是同一个集合内，发现并没有，合并集合，同时总的岛屿数量- 1，变成2，效果如下图：

之后再无符合条件，所以最后求出岛屿的数量是2，大家可以试试四台机器或者更多机器的时候，是一样的。