普利姆算法的理解

package a;

import java.util.Arrays;

public class PrimDemo
{
    public static void main(String[] args) {
        char[] diots = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        int count = diots.length;
        int[][] edges = {
                {100000, 5, 7, 100000, 100000, 100000, 2},
                {5, 100000, 100000, 9, 100000, 100000, 3},
                {7, 100000, 100000, 100000, 8, 100000, 100000},
                {100000, 9, 100000, 100000, 100000, 4, 100000},
                {100000, 100000, 8, 100000, 100000, 5, 4},
                {100000,100000,100000,4,5,100000,6},
                {2, 3, 100000, 100000, 4, 6, 100000,}

        };

        MinTree tree = new MinTree();
        MyGraph gr = new MyGraph(count);//因为是数组必须要初始化。
        tree.createGraph(gr,count,diots,edges);
//        tree.show(gr);
        tree.prim(gr,0);
    }

}

class MinTree{
//    MyGraph my;


    public void prim(MyGraph my, int index) {
        int[] visited = new int[my.len];
        visited[index]=1;
        int i1 = -1;
        int i2 = -2;
        for (int i = 1; i < visited.length; i++) {//根据节点的个数会得出 -1 个边  所以控制只次数
            int minvlue = 100000;//这个每次循环要更新，尤为重要。
            for (int j = 0; j < visited.length; j++) {//外层控制访问过的节点。这个for结束后会出现所有访问过后的节点的最小值  这个其实就是贪心算法，每次找到一个最短的路径。
                for (int k = 0; k < visited.length; k++) {//内层控制没访问过得节点。  这个for结束后，会出现一个节点周围的最小值。
                    if (visited[j] == 1 && visited[k] != 1 && my.value[j][k] < minvlue) {
                        minvlue = my.value[j][k];
                        i1 = j;
                        i2 =k;

                    }
                }
            }
            System.out.println(my.data[i1]+"---"+my.data[i2]+":"+minvlue);
            visited[i2]=1;
        }

    }
    public void createGraph(MyGraph my,int len, char[] data, int[][] value) {//这个方法只是用于加工。 传进来的值。
        for (int i = 0; i < data.length; i++) {
            my.data[i] = data[i];
            for (int j = 0; j < data.length; j++) {
                my.value[i][j] = value[i][j];
            }
        }


    }

    public void show(MyGraph myGraph){
        for (int[] e : myGraph.value) {
            System.out.println(Arrays.toString(e));
        }

    }
}

class MyGraph{
    int len;
    char [] data;
    int [][] value;

    public MyGraph(int len) {
        data = new char[len];
        value = new int[len][len];
        this.len = len;
    }
}

对于这个算法，第一步必须是有一个已经访问的点了。
从这个点出发找到第一个最近的点，
然后是两个点找到最近的点。
第三次就是三个点找到最近的点
以此类推。

需要保存是否访问过的点，一个数组
需要保存每次找到的，最短的那两个点，因为用的是数组。我们保存下标
需要每次找到最小的权值，一个变量。 变量每次找之前要初始化。
每次找完，要把对应的下标保存，以及访问过保存。以及变量初始化，可以把该做的都放在找到后处理。容易理解。和之前的贪心算法一样。