Prim算法实现

1.主要思想

	Prim算法，从图的某一个顶点开始，找到权值最小的顶点，依次遍历，最后生成一个最小生成树

2.图示

![在这里插入图片描述](https://img-blog.csdnimg.cn/20200809132444220.PNG)

3.代码实现

1.图

package prim;

public class Graph {
    int vertex; // 顶点的个数
    char[] value; // 顶点的值
    int[][] weight;// 图的邻接矩阵

    public Graph() {
    }

    public Graph(int vertex) {
        this.vertex = vertex;
        value = new char[vertex];
        weight = new int[vertex][vertex];
    }
}

2.最小生成树

package prim;

import jdk.dynalink.NamedOperation;

import java.util.Arrays;

public class MinTree {
    /**
     * 创建图的邻接矩阵
     *
     * @param graph  图
     * @param vertex 顶点个数
     * @param value  顶点的值
     * @param weight 邻接矩阵
     */
    public void CreatGraph(Graph graph, int vertex, char[] value, int[][] weight) {
        for (int i = 0; i < vertex; i++) {
            for (int j = 0; j < vertex; j++) {
                graph.value[i] = value[i];
                graph.weight[i][j] = weight[i][j];
            }
        }
    }

    /**
     * 显示图的邻接矩阵
     *
     * @param graph 图
     */
    public void ShowGraph(Graph graph) {
        for (int[] arr : graph.weight) {
            System.out.print(Arrays.toString(arr));
            System.out.println();
        }

    }
    /**
     * Prim算法
     *
     * @param graph  图
     * @param vertex 从指定节点(索引)开始成最小生成树
     */
    public void Prim(Graph graph, int vertex) {
        // 记录顶点是否被访问过 0->未被访问，1->已经被访问
        int[] visited = new int[graph.vertex];
        // 将传入的顶点设置为已经访问过
        visited[vertex] = 1;
        // 初始化两个顶点索引
        int v1 = -1, v2 = -1;
        // 定义一个无穷大的值，用于替换顶点之间的距离
        int MaxValue = Integer.MAX_VALUE;
        // graph.vertex个顶点，使用Prim算法，生成的最小生成树有graph.vertex-1条边
        for (int edge = 1; edge < graph.vertex; edge++) {

            // 遍历已经访问过的边
            for (int isVisit = 0; isVisit < graph.vertex; isVisit++) {
                // 遍历没有访问过的边
                for (int NoVisited = 0; NoVisited < graph.vertex; NoVisited++) {
                    // 如果找到距离小的顶点，就替换
                    if (visited[isVisit] == 1 && visited[NoVisited] == 0 && graph.weight[isVisit][NoVisited] < MaxValue) {
                        MaxValue = graph.weight[isVisit][NoVisited];
                        v1 = isVisit;
                        v2 = NoVisited;
                    }
                }
            }
            // 一趟循环结束，就找到了从指定顶点到邻接顶点权值最小的边
            System.out.println("<" + graph.value[v1] + "," + graph.value[v2] + ">" + "权值:" + MaxValue);
            // 将当前顶点标记为已访问
            visited[v2] = 1;
            // 将无穷大值重新赋值
            MaxValue = Integer.MAX_VALUE;

        }
    }
}

3.入口

package prim;

public class Input {
    public static void main(String[] args) {
        // 图的顶点数组
        char[] value = {'A', 'B', 'C', 'D'};
        // 定义一个无穷大的数，表示顶点不能直达的长度
        int infinity = Integer.MAX_VALUE;
        // 定义邻接矩阵
        int[][] weight = {
                {infinity, 100, 20, infinity},
                {100, infinity, 70, 60},
                {20, 70, infinity, 50},
                {infinity, 60, 50, infinity}
        };
        // 创建图对象
        Graph graph = new Graph(value.length);
        // 创建最小生成树对象
        MinTree minTree = new MinTree();
        // 创建邻接邻接矩阵
        minTree.CreatGraph(graph, value.length, value, weight);
        minTree.ShowGraph(graph);
        // Prim算法
        minTree.Prim(graph, 0);
    }
}