常用的十种算法--克鲁斯卡尔算法

1.克鲁斯卡尔算法应用场景：

        使用克鲁斯卡尔算法生成最小生成树。

2.克鲁斯卡尔算法介绍：

        克鲁斯卡尔算法的核心思想是：在带权连通图中，不断地在边集合中找到最小的边，如果该边满足得到最小生成树的条件，就将其构造，直到最后得到一颗最小生成树。

3.克鲁斯卡尔算法示意图：

 4.首先，将图中所有的边排序（从小到大），我们将以此结果来选择。排序后各边按权值从小到大依次是：

HG < (CI=GF) < (AB=CF) < GI < (CD=HI) < (AH=BC) < DE < BH < DF

接下来，我们先选择HG边，将这两个点加入到已找到点的集合。这样图就变成了：

继续，这次选择边CI（当有两条边权值相等时，可随意选一条），此时需做判断。

判断法则：当将边CI加入到已找到边的集合中时，是否会形成回路？

1、如果没有形成回路，那么直接将其连通。此时，对于边的集合又要做一次判断：这两个点是否在已找到点的集合中出现过？

• 如果两个点都没有出现过，那么将这两个点都加入已找到点的集合中；
• 如果其中一个点在集合中出现过，那么将另一个没有出现过的点加入到集合中；
• 如果这两个点都出现过，则不用加入到集合中。

2、如果形成回路，不符合要求，直接进行下一次操作。

根据判断法则，不会形成回路，将点C和点I连通，并将点C和点I加入到集合中。

  

 4.代码实现：

package algorithm.krusk;

/**
 * @author WuChenGuang
 */
public class Edge implements Comparable<Edge>{

    int begin;
    int end;
    int weight;

    @Override
    public int compareTo(Edge o) {
        return this.weight-o.weight;
    }
}

package algorithm.krusk;

/**
 * @author WuChenGuang
 */
public class Graph {

    Edge[] edges;

    int[][] array;
}

package algorithm.krusk;

import java.util.Arrays;

/**
 * @author WuChenGuang
 */
public class KruskalAlg {
    public static void main(String[] args) {

        Graph graph = new Graph();
        int[][] array = new int[7][7];
        for (int i = 0; i < 7; i++) {
            for (int j = 0; j < 7; j++) {
                if (i == j) {
                    array[i][j] = 0;
                } else {
                    array[j][i] = Integer.MAX_VALUE;
                }
            }
        }

        array[0][1] = 7;
        array[0][3] = 5;
        array[1][2] = 8;
        array[1][3] = 9;
        array[2][4] = 5;
        array[3][4] = 15;
        array[4][5] = 8;
        array[4][6] = 9;
        array[5][6] = 11;

        graph.array = array;
        int k = 0;
        Edge[] edge = new Edge[11];
        for (int i = 0; i < edge.length; i++) {
            Edge edge1 = new Edge();
            edge[i] = edge1;
        }

        for (int i = 0; i < 6; i++) {
            for (int j = i + 1; j < 7; j++) {
                if (array[i][j] < Integer.MAX_VALUE) {
                    edge[k].begin = i;
                    edge[k].end = j;
                    edge[k].weight = array[i][j];
                    k++;
                }
            }
        }

        graph.edges = edge;
        Arrays.sort(edge);
        kruskal(graph);
    }

    /**
     * 是否会构成回路
     */
    public static int findParentRoot(int target, int[] parent) {
        while (parent[target] > 0) {
            target = parent[target];
        }
        return target;
    }

    public static void kruskal(Graph graph) {
        Edge[] edges = graph.edges;
        int[][] arr = graph.array;
        int[] parent = new int[7];

        for (Edge edge : edges) {
            int begin = findParentRoot(edge.begin, parent);
            int end = findParentRoot(edge.end, parent);
            if (begin != end) {
                System.out.println(String.format("(%d,%d)--->%d", begin, end, edge.weight));
                parent[begin] = end;
            }
        }
    }
}

运行结果：