超简单实现普利姆算法

思路： 随便找出一个点，接着找出与这个点权值最小的路径，这样我们就有两个点了。

把这两个点看成一个大点，接着在剩余点中寻找与大点权值最小的路径，找到以后我们就有了一个更大的点。

以此类推，知道所有点都添加完毕。（如果没看懂代码里注解更清晰）。

---

import javax.swing.*;
import java.util.Arrays;
import java.util.HashMap;

/**
 * @author 王木风
 * @create 2020-08-25 10:36
 * 布鲁斯卡尔算法
 */
public class PrimAlgorithm {
    public static void main(String[] args) {
        HashMap<Integer, String> hashMap = new HashMap<>(); //下面这么写纯粹是省地方
        hashMap.put(0,"A");  hashMap.put(1,"B");
        hashMap.put(2,"C");  hashMap.put(3,"D");
        hashMap.put(4,"E");  hashMap.put(5,"F");
        hashMap.put(6,"G");
        int verxs = hashMap.size();
        int[][] onde = new int[verxs][verxs];
        onde[0][1] = 5;  onde[0][2] = 7;  onde[0][6] = 2;  onde[1][0] = 5;
        onde[1][3] = 9;  onde[1][6] = 3;  onde[2][0] = 7;  onde[2][4] = 8;
        onde[3][1] = 9;  onde[3][5] = 4;  onde[4][2] = 8;  onde[4][5] = 5;
        onde[4][6] = 4;  onde[5][3] = 4;  onde[5][4] = 5;  onde[5][6] = 6;
        onde[6][0] = 2;  onde[6][1] = 3;  onde[6][4] = 4;  onde[6][5] = 6;
        prinm(onde,hashMap);
    }

    public static void prinm(int[][] onde,HashMap<Integer,String> hashMap) {
        int nextNode = 0;    //存放下一个应该放的结点
        int nodeNumber = 1;  //记录共有几个顶点了
        int[] recordAfterNode = new int[hashMap.size()];
        while (nodeNumber<7) {  //因为7个结点
            int min = 100;
            int min2 = 100;
            HashMap<Integer, Integer> integerIntegerHashMap = new HashMap<>();  //存放每一行的最小值和列数（列数就是目标地点，行数是起始地点）
            int[] recordFrontNode = new int[nodeNumber];  //recordFrontNode容量随着顶点数而变化，里面存放的是已经遍历过的点
            System.arraycopy(recordAfterNode, 0, recordFrontNode, 0, recordFrontNode.length);
            for (int a :recordFrontNode) {
                for (int i = 0; i < hashMap.size(); i++) {
                    if (onde[a][i] < min && onde[a][i] > 0) {   //寻找最小值和列数
                        min = onde[a][i];
                        nextNode = i;
                    }
                }
                integerIntegerHashMap.put(min,nextNode);
                min = 100;
            }
            for (Integer integer :integerIntegerHashMap.keySet()) { //寻找每列最小值之间的最小值
                if (integer < min2 && integer > 0) {
                    min2 = integer;
                }
            }
            recordAfterNode[nodeNumber] = integerIntegerHashMap.get(min2);  //最终结果存放到recordAfterNode
            nodeNumber++;   //已经处理过的节点数+1
            for (int a :recordAfterNode) {  //处理过的点之间断开，防止出现闭环。我认为这也是区分贪心算法和普利姆算法的地方
                for (int b :recordAfterNode) {
                    onde[a][b] = 0;
                }
            }
        }
        for (int i :recordAfterNode) {
            System.out.print(hashMap.get(i)+"->");
        }
    }
}

如果还有不懂的地方欢迎留言或者私聊。
如果有错误的地方也欢迎大佬指正。