Day595.普利姆算法 -数据结构和算法Java

Posted 2022-04-25 阿昌喜欢吃黄桃

普利姆算法

一、问题引出

二、最小生成树

三、普利姆算法介绍

四、图解分析

---

五、代码实现

package com.achang.algorithm;

import java.util.Arrays;

/**
 * 普利姆算法
 */
public class PrimAlgorithm 
    public static void main(String[] args) 

        //初始化最小生成树
        char[] data = 'a','b','c','d','e','f','g';
        //临界矩阵的关系，用10000表示不连通
        int[][] weight = new int[][]
                //a,b,c,d,e,f,g
                10000,5,7,10000,10000,10000,2,//a
                5,10000,10000,9,10000,10000,3,//b
                7,10000,10000,10000,8,10000,10000,//c
                10000,9,10000,10000,10000,4,10000,//d
                10000,10000,8,10000,10000,5,4,//e
                10000,10000,10000,4,5,10000,6,//f
                2,3,10000,10000,4,6,10000,//g
        ;

        Graph graph = new Graph(data.length);
        MinTree minTree = new MinTree();
        minTree.createGraph(graph,
                data.length,
                data,
                weight);
        minTree.list(graph);
        //使用普利姆算法生成最小生成树
        minTree.prim(graph,0);



    


//创建最小生成树，村庄图
class MinTree
    /**
     * 创建图的临界矩阵
     * @param graph 图对象
     * @param verxs 图对应的节点个数
     * @param data 图各个节点的值
     * @param weight 图的临界矩阵
     */
    public void createGraph(Graph graph,int verxs,char[] data,int[][] weight)
        int i,j;
        for (i = 0; i < verxs; i++) 
            graph.data[i] = data[i];
            for (j = 0; j < verxs;j++)
                graph.weight[i][j] = weight[i][j];
            
        
    

    //遍历图的临界矩阵
    public void list(Graph graph)
        for (int[] ints : graph.weight) 
            System.out.println(Arrays.toString(ints));
        
    

    /**
     * 普利姆算法，得到最小生成树
     * @param graph 图结构
     * @param v 表示从图结构的第几个节点开始生成 'a'->0
     *                                    'b'->1
     *                                    'c'->2
     *                                     .....
     */
    public void prim(Graph graph,int v)
        //表示标记节点是否被访问过，元素值为0，表示没有被访问过
        int[] visited = new int[graph.verxs];

        visited[v] = 1;
        //用h1、h2记录两个节点的下标
        int h1 = -1;
        int h2 = -1;
        //初始化minWeight为一个大数，后面会被替换更改
        int minWeight = 10000;

        //因为有graph.verxs个节点，那普利姆算法结束后，有graph.verxs-1条边
        //确定每一次生成的子图，和哪个节点和这次遍历节点的记录【权值】最近
        for (int i = 1; i < graph.verxs; i++) //i节点表示，被访问过的节点
            for (int j = 0; j < graph.verxs; j++) //j节点表示，还没有访问过的节点
                for (int k = 0; k < graph.verxs; k++) 
                    if (visited[j]==1 && visited[k] == 0 && graph.weight[j][k] < minWeight)
                        //替换minWeight，寻找已经访问过的节点和未访问过的节点间，权值最小的边
                        minWeight = graph.weight[j][k];
                        //并记录此节点的下标
                        h1 = j;
                        h2 = k;
                    
                
            
            //退出了上面的for循环后就找到了这条边
            System.out.println("边<"+graph.data[h1]+","+graph.data[h2]+">权值："+minWeight);
            //将当前节点，标记为已访问节点
            visited[h2] = 1;
            //重置minWeight
            minWeight = 10000;
        
    



//图结构
class Graph
    int verxs;//图节点个数
    char[] data;//保存节点的数据
    int[][] weight;//存放边值，临界矩阵

    public Graph(int size)
        this.verxs = size;
        data = new char[verxs];
        weight = new int[verxs][verxs];