java手写并查集算法应用拓展案例

Java手写并查集算法应用拓展案例

1. 并查集算法应用思路

并查集是一种用于处理不相交集合的数据结构，它支持合并（union）和查找（find）两种操作。并查集常用于解决集合合并、连通性问题等。
并查集算法的应用拓展案例主要分为以下几个步骤：

1. 创建一个UnionFind类，该类包含一个数组parent和一个变量count，用于存储节点的父节点和记录集合的个数。

2. 在UnionFind类中，实现find方法，用于查找节点的根节点，并进行路径压缩优化。

3. 在UnionFind类中，实现union方法，用于合并两个节点的集合。如果两个节点已经处于同一个集合中，则说明存在环。

4. 创建一个新的类，用于解决具体的问题。在这个类中，先创建一个UnionFind对象，初始化所有节点的父节点为自身，并将count设置为节点的个数。

5. 遍历问题中的数据结构（如图的边、邻接矩阵等），根据具体问题的要求，调用UnionFind类中的union方法，合并两个节点的集合。

6. 最后，调用UnionFind类中的getCount方法，获取最终的结果。具体问题的解决方法可能会有所不同，但整体的思路是相似的。

通过这样的步骤，可以将并查集算法应用到不同的问题中，实现高效的解决方案。

2. 案例一：判断无向图中是否存在环

class UnionFind {
    private int[] parent;

    public UnionFind(int n) {
        parent = new int[n];
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }

    public int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }

    public boolean union(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        if (rootX == rootY) {
            return false;
        }
        parent[rootX] = rootY;
        return true;
    }
}

public class GraphCycleDetection {
    public boolean hasCycle(int[][] edges) {
        int n = edges.length;
        UnionFind uf = new UnionFind(n);
        for (int[] edge : edges) {
            int u = edge[0];
            int v = edge[1];
            if (!uf.union(u, v)) {
                return true;
            }
        }
        return false;
    }
}

代码解释：

• UnionFind类是并查集的实现，其中parent数组用于存储每个节点的父节点。
• find方法用于查找节点x的根节点，并进行路径压缩优化。
• union方法用于合并两个节点x和y的集合，如果它们已经处于同一个集合中，则说明存在环。
• GraphCycleDetection类用于判断无向图中是否存在环。通过遍历所有边，将每条边的两个节点进行合并操作，如果发现某条边的两个节点已经处于同一个集合中，则说明存在环。

3. 案例二：计算连通分量个数

class UnionFind {
    private int[] parent;
    private int count;

    public UnionFind(int n) {
        parent = new int[n];
        count = n;
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }

    public int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }

    public void union(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        if (rootX == rootY) {
            return;
        }
        parent[rootX] = rootY;
        count--;
    }

    public int getCount() {
        return count;
    }
}

public class ConnectedComponents {
    public int countComponents(int n, int[][] edges) {
        UnionFind uf = new UnionFind(n);
        for (int[] edge : edges) {
            int u = edge[0];
            int v = edge[1];
            uf.union(u, v);
        }
        return uf.getCount();
    }
}

代码解释：

• UnionFind类的实现与前面的案例一相同，不同之处在于增加了count变量，用于记录当前的连通分量个数。
• union方法中，每次合并两个节点的集合时，将count减1。
• ConnectedComponents类用于计算无向图中的连通分量个数。通过遍历所有边，将每条边的两个节点进行合并操作，并更新count的值。

4. 案例三：求解朋友圈个数

class UnionFind {
    private int[] parent;
    private int count;

    public UnionFind(int n) {
        parent = new int[n];
        count = n;
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }

    public int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }

    public void union(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        if (rootX == rootY) {
            return;
        }
        parent[rootX] = rootY;
        count--;
    }

    public int getCount() {
        return count;
    }
}

public class FriendCircles {
    public int findCircleNum(int[][] M) {
        int n = M.length;
        UnionFind uf = new UnionFind(n);
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (M[i][j] == 1) {
                    uf.union(i, j);
                }
            }
        }
        return uf.getCount();
    }
}

代码解释：

• UnionFind类的实现与前面的案例二相同。
• FriendCircles类用于求解朋友圈个数。通过遍历邻接矩阵，如果两个人是朋友关系，则将它们的节点进行合并操作，并更新count的值。

5.案例四：用于求解岛屿的数量问题

class UnionFind {
    private int[] parent;
    private int count;

    public UnionFind(char[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        parent = new int[m * n];
        count = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == '1') {
                    parent[i * n + j] = i * n + j;
                    count++;
                }
            }
        }
    }

    public int find(int x) {
        if (parent[x] != x) {
            parent[x] = find(parent[x]);
        }
        return parent[x];
    }

    public void union(int x, int y) {
        int rootX = find(x);
        int rootY = find(y);
        if (rootX == rootY) {
            return;
        }
        parent[rootX] = rootY;
        count--;
    }

    public int getCount() {
        return count;
    }
}

public class NumberOfIslands {
    public int numIslands(char[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        UnionFind uf = new UnionFind(grid);
        int[][] directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == '1') {
                    for (int[] dir : directions) {
                        int newRow = i + dir[0];
                        int newCol = j + dir[1];
                        if (newRow >= 0 && newRow < m && newCol >= 0 && newCol < n && grid[newRow][newCol] == '1') {
                            uf.union(i * n + j, newRow * n + newCol);
                        }
                    }
                }
            }
        }
        return uf.getCount();
    }
}

代码解释：

• UnionFind类的实现与前面的案例相同，不同之处在于构造函数的参数为二维字符数组grid，用于初始化并查集。
• NumberOfIslands类用于求解岛屿的数量。通过遍历二维字符数组，如果当前位置为陆地，则将其与上下左右位置的陆地进行合并操作，并更新count的值。

这个代码用于解决岛屿的数量问题，其中岛屿被定义为被水包围的陆地，每个格子只能与上下左右四个方向的格子相连。通过并查集算法，可以高效地计算出岛屿的数量。

总结

本文介绍了并查集算法的三个拓展应用案例，并给出了完整的代码实现。这些案例分别用于判断无向图中是否存在环、计算连通分量个数以及求解朋友圈个数。并查集算法在解决这些问题时具有高效的特点，能够有效地提高算法的执行效率。
并查集算法是一种用于解决集合合并和查询问题的高效数据结构和算法。它通过维护一个树形结构来表示集合，并通过路径压缩和按秩合并等优化策略来提高算法的效率。

拓展总结

并查集算法的基本操作包括：

• 初始化：将每个元素的父节点初始化为自身，表示每个元素都是一个独立的集合。
• 查找：通过递归或迭代的方式查找元素所属的集合，找到根节点作为集合的代表。
• 合并：将两个元素所属的集合合并为一个集合，即将一个根节点的父节点指向另一个根节点。

并查集算法的应用非常广泛，常见的应用场景包括：

• 连通性问题：判断两个元素是否属于同一个集合，用于解决网络连接、社交网络关系等问题。
• 最小生成树：用于求解图的最小生成树，例如Kruskal算法。
• 图的连通分量：用于求解图的连通分量个数，例如求解岛屿的数量问题。
• 环的检测：用于判断图中是否存在环，例如判断有向图中是否存在循环依赖。

总结起来，通过并查集算法，可以高效地解决一些集合合并和查询问题，特别适用于解决连通性问题和图论相关的应用。并查集算法的核心思想是将集合划分为不相交的子集，通过合并操作将不同的集合合并为一个集合，从而实现高效的查询和操作。