普里姆算法求最小生成树

前提创建一个二维的邻接矩阵。算法的大概内容，首先创建两个数组，一个数组lowest初始化存储二维矩阵的第一行，另一个数组adjvex的数组初始化为0，第一个a[0]为零代表第一个顶点纳入生成树。

通过循环比较，查找到lowest中最小的值，对应的位置index的顶点就是即将纳入生成数的顶点

然后将index顶点对应的行和lowest进行比较，将每列的最小值保存到lowest的对应位置，此时，lowest的中存放的是新的生成树的到其他顶点的最小权值

adjvex数组中的元素主要存放，当需要输出最小权值的边时所需要的起点

1.邻接矩阵数据结构：

public class Graph {
    String[] vertex = new String[5];    //顶点类型可自定义
    int[][] edge = new int[5][5];       //边的类型可自定义

//省略set,get方法}

2.普鲁姆算法实现

图的数据结构

public class Graph {
    String[] vertex = new String[5];    //顶点类型可自定义
    int[][] edge = new int[5][5];       //边的类型可自定义

//省略get,set方法}

/**
     * 使用普鲁姆算法实现邻接矩阵的最小生成树
     * @param g
     */
    public static void minimunSpan_prim(Graph g){

        int[] adjvex = new int[5];  //假定5个   存放边的起点，v0即为0
        int[] lowest = new int[5];  //存放生成树的最小权值

        //初始化
        for(int i = 0; i < 5; i++){
            lowest[i] = g.getEdge()[0][i];      //首先存放邻接矩阵的第一行的值，即v0的权值 因为目前生成树只有v0顶点
            adjvex[i] = 0;                      //初始化为0
        }

        for(int i = 1; i < adjvex.length; i++){ //第一个为v0,只需要遍历其他n-1个结点
           int min = 65535;   //理论上为无穷大，一般去65535等不常用的数字
            int j = 1;          //从与v0相连的第1个顶点开始
            int index = 0;      //用于记录顶点的位置
            while(j < adjvex.length){       //找出这一行的最小值，即找出对应下标的顶点权值最小
                if(lowest[j] != 0 && lowest[j] < min){      //之所以不能为0是因为当顶点被纳入生成树时，lowest中对应的位置
                                                            //设为0
                    min = lowest[j];
                    index = j;
                }
                j++;
            }
            System.out.println("权值最小边：(" + adjvex[index] + "," + index + ")");
            lowest[index] = 0;      //该位置的顶点已经被纳入生成树，因此不计入生成树集到该顶点的权
            for(j = 1; j < adjvex.length; j++){  //将该顶点对应的行与lowest做比较，lowest始终存放最小值，即生成树对应的最小值
                if(lowest[j] != 0 && g.getEdge()[index][j] < lowest[j]){
                    lowest[j] = g.getEdge()[index][j];
                    adjvex[j] = index;
                }
            }
        }
    }

}

3.创建二维邻接矩阵进行测试

public class GraphApp {

    public static void main(String[] args){
        Graph g = createGraphByMatrix();
        MinimunSpanningTree.minimunSpan_prim(g);
    }

    /**
     * 邻接矩阵创建图
     * 顶点集合 {A,B,C,D,E}
     * 边集合{（A,B),(B,C),(C,D),(D,E),(E,A),(A,C)} ->{(0,1),(1,2),(2,3),(3,4),(4,1),(0,2)}
     * 顶点数就是二维数组边集的维数
     */
    public static Graph createGraphByMatrix(){
        Graph g = new Graph();
        Scanner sc = new Scanner(System.in);
        //给顶点赋值，此处只是赋予名称
        for(int i = 0; i < g.getVertex().length; i++){
            System.out.println("输入顶点名称：");
            String vertexName = sc.next();
            g.getVertex()[i] = vertexName;
        }
        //初始化邻接矩阵
       for(int i = 0; i < g.getVertex().length; i++){
            for(int j = 0; j < g.getVertex().length; j++){
                if(i == j ){
                    g.getEdge()[i][j] = 0;       //自己到自己，设值为0
                }else{

                    g.getEdge()[i][j] = 65535;             //两顶点之间没有边  此处我们用 65535代替   一般用无穷大代替
                }
            }
       }

       //输入边数
        System.out.println("输入边数：");
        int edgeNum = sc.nextInt();
        int edgeMaxNum = g.getVertex().length * (g.getVertex().length-1)/2;  //无向图最大边数  n*(n-1)/2
        if(edgeNum > edgeMaxNum){
            System.out.println("边数不能超过无向图的最大边数！");
            System.exit(0);
        }
       //给邻接矩阵赋值
        for(int i = 0; i < edgeNum; i++){
            System.out.println("输入边（vi,vj）上的下标i");
            int edgI = sc.nextInt();
            System.out.println("输入边（vi,vj）上的下标j");
            int edgJ = sc.nextInt();
            System.out.println("输入边（vi,vj）上的权值：");
            int weight = sc.nextInt();
            g.getEdge()[edgI][edgJ] = weight;
            g.getEdge()[edgJ][edgI] = weight;       //无向图有对称性 a[i][j] = a[j][i]

        }
        return g;
    }

}

4.测试结果

输入条件（边的起点，边的终点，权值）：（0,1,1），（1,2,3），（2,3,4），（3,4,4），（4,0,5），（1,4,3）

权值最小边：(0,1)
权值最小边：(1,2)
权值最小边：(1,4)
权值最小边：(2,3)