Kruskal(克鲁斯卡尔算法)

Kruskal(克鲁斯卡尔算法)

学习视频：尚硅谷数据结构与算法

用于求带权连通图的最小生成树的算法

算法流程

1. 将带权连通图的边按照权值大小进行排序。
2. 遍历排序之后的结果，判断边是否构成回路，构成回路则跳过，不构成回路则加入到最小生成树集合之中。

算法的核心在于如何判断是否构成回路，通过记录该顶点的终点，判断终点是否相同来判断是否产生回路。

核心算法代码：

 /**
     * 
     * @param ends 终点数组
     * @param i 当前节点的下标
     * @return 返回节点的终点
     */
public int getEnd(int[] ends, int i) {
    //while循环来自动获取最新的终点，非常巧妙
        while (ends[i] != 0) {
            i = ends[i];
        }
        return i;
    }

    public void kruskal() {
        int index = 0;
        Edge[] mst = new Edge[graph.vertex - 1];
        int[] ends = new int[graph.vertex];
        Edge[] edges = getEdges();
        sortEdges(edges);
        for (Edge edge : edges) {
            int start = getPosition(edge.start);
            int end = getPosition(edge.end);
            int  m = getEnd(ends, start);
            int n = getEnd(ends, end);
            if (m != n) {
                //更新终点数组， 这里不能通过start 和 end来				更新，具体原因自己dbug
                ends[m] = n;
                mst[index++] = edge;
            }
        }
        System.out.println(Arrays.toString(mst));
    }

公交站问题

代码实现：

package Algorithm.kruskalAlgorithm;

import java.util.Arrays;
import java.util.Comparator;

public class KruskalAlgorithm {
    Graph graph;
    private final int INF = Integer.MAX_VALUE;
    public KruskalAlgorithm(int[][] matrix, char[] data, int vertex) {
        graph = new Graph(vertex);
        graph.matrix = matrix;
        graph.data = data;
    }

    //获取当前字符的坐标
    public int getPosition(char ch) {
        return graph.getPosition(ch);
    }

    //将边进行排序
    public void sortEdges(Edge[] edges) {
        Arrays.sort(edges, Comparator.comparingInt(x -> x.weight));
    }

    public int numOfEdges() {
        int count = 0;
        for (int i = 0; i < graph.matrix.length; i++) {
            for (int j = i + 1; j < graph.matrix[0].length; j++) {
                if (graph.matrix[i][j] != INF) count++;
            }
        }
        return count;
    }

    public Edge[] getEdges() {
        int index = 0;
        Edge[] edges = new Edge[numOfEdges()];
        for (int i = 0; i < graph.matrix.length; i++) {
            for (int j = i + 1; j < graph.matrix[0].length; j++) {
                if (graph.matrix[i][j] != INF) {
                    edges[index++] = new Edge(graph.data[i], graph.data[j], graph.matrix[i][j]);
                }
            }
        }
        return edges;
    }

    /**
     *
     * @param ends 终点数组
     * @param i 当前节点的下标
     * @return 返回节点的终点
     */
    public int getEnd(int[] ends, int i) {
        while (ends[i] != 0) {
            i = ends[i];
        }
        return i;
    }

    public void kruskal() {
        int index = 0;
        Edge[] mst = new Edge[graph.vertex - 1];
        int[] ends = new int[graph.vertex];
        Edge[] edges = getEdges();
        sortEdges(edges);
        for (Edge edge : edges) {
            int start = getPosition(edge.start);
            int end = getPosition(edge.end);
            int  m = getEnd(ends, start);
            int n = getEnd(ends, end);
            if (m != n) {
                ends[m] = n;
                mst[index++] = edge;
            }
        }
        System.out.println(Arrays.toString(mst));
    }

}
//内部类 图
class Graph {
    int vertex;
    char[] data;
    int[][] matrix;
    public Graph(int vertex) {
        this.vertex = vertex;
        data = new char[vertex];
        matrix = new int[vertex][vertex];
    }

    public int getPosition(char ch) {
        for (int i = 0; i < data.length; i++) {
            if (data[i] == ch) return i;
        }
        return -1;
    }
}
//内部类 边
class Edge {
    char start;//起点
    char end;//终点
    int weight;//权值
    
    public Edge(char start, char end, int weight) {
        this.start = start;
        this.end = end;
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "<" + start +
                ", " + end +
                ">" + weight +
                '}';
    }
}

测试代码：

public class Client {

    public static void main(String[] args) {
        char[] vertex = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        int INF = Integer.MAX_VALUE;
        int[][] matrix = { {0, 12, INF, INF, INF, 16, 14},
                 {12, 0,10, INF, INF, 7,INF},
                {INF, 10, 0,3, 5,6, INF},
                {INF, INF, 3,0, 4,INF, INF},
                { INF, INF, 5, 4, 0, 2, 8},
                { 16, 7, 6, INF, 2, 0, 9},
                { 14, INF, INF, INF, 8, 9, 0}};
        KruskalAlgorithm kruskalAlgorithm = new KruskalAlgorithm(matrix, vertex, vertex.length);
        kruskalAlgorithm.kruskal();
    }
}