普里姆算法最小生成树_伪代码来理解普里姆算法

1.快速了解Prim算法

学过数据结构的看官老爷们都应该知道，普里姆太熟悉了，不就是最小生成树的算法嘛，是的它是一种求最小树的算法。本文通过剖析伪代码的过程来理解这个“easy algorithm”。

话不多说下面先描述下算法：

运算方法是任取一个点，以这个点为集合开始，然后对所有点与这个点的距离进行更新，找出离这个集合最近的点，然后把这个点放进这个集合(所以每一次运算的时候都要判断一下这个点是否在这个集合里，所有要用到一个vset数组)更新权值，然后再以这个集合继续寻找离这个集合最近的点，直到没有点存在。

2.伪代码讲解Prim算法

第一个for 循环初始化最小权值结集合(表示最小生成树到结点v的权值)，V为 所有顶点的集合 .

随机选取一个顶点作为起始顶点并加入集合U(最小生成树的结点).

对所有结点进行while循环，N(U)表示结点集合

第二for循环从剩余结点选取到当前最小生成树的最小路径权值的点。 记录结点u->v的路径权值集合如果小于则将更新的值为,记录可能选取的结点，

选取新的结点后更新集合U，以及F(存储最小生成树边的集合)，

也许不大好理解下面我们来看个例子吧

image-20200928001139390

下表是最小生成树的简化过程，只列举了生成树的有效步骤没有将所有可能情况列出

u	v	U	V	π(v)	P(v)	F
a	d	{a,d,b}	{a,b,c,d,e,f,g,h}	5	d	{a->d}
d	b	{a,d}	{a,b,c,d,e,f,g,h}	8	b	{a->d,d->b}
a	c	{a,d,b,c}	{a,b,c,d,e,f,g,h}	9	c	{a->d,d->b,a->c}
b	f	{a,d,b,c,f}	{a,b,c,d,e,f,g,h}	9	f	{a->d,d->b,a->c,b->f}
f	e	{a,d,b,c,f,e}	{a,b,c,d,e,f,g,h}	6	e	{a->d,d->b,a->c,b->f,f->e}
e	g	{a,d,b,c,f,e,g}	{a,b,c,d,e,f,g,h}	5	g	{a->d,d->b,a->c,b->f,f->e,e->g}
g	h	{a,d,b,c,f,e,g,h}	{a,b,c,d,e,f,g,h}	10	h	{a->d,d->b,a->c,b->f,f->e,e->g,g->h}

3. JAVA实现最小生成树

import java.util.Map;

public class Prim {

    static int min = 65535;
    public static void prim(int[][] graph, int n){

        //定义结点
        char[] c = new char[]{'a','b','c','d','e','f','g','e','f'};
        //存放当前生成树到剩余各顶点最短权值的边
        int[] lowcost = new int[n];
        //标记顶点是否加入到生成树中，初始值全为0
        int[] vset = new int[n];
        int i, j, minid = 0, sum = 0;

        //初始化vset,lowcost
        for(i = 0; i             vset[i] = 0;
            lowcost[i] = graph[0][i];
        }
        //将结点a加入到生成树中
        vset[0] = 1;

        for(i = 0; i 1; ++i){
            min = 65535;
            //寻找最短边
            for(j = 0;j                 if(vset[j]==0 && lowcost[j]                     min = lowcost[j];
                    minid = j;
                }
            vset[minid] = 1;
            sum += min;
            //获取父节点方便打印
            int temp = 0;
            for(int x = 0; x                if(graph[x][minid] == min)
                {temp = x;break;}
            System.out.println(c[temp]+"->"+c[minid]);
            //加入新结点后更新lowcost
            for (j = 0; j                 if(vset[j]==0&&graph[minid][j]                    lowcost[j] = graph[minid][j];
                }


        }
        System.out.println(sum);
    }


    public static void main(String[] args) {
        int MAX = 65535;
        int[][] map = new int[][]{
                {0,10,9,5,MAX,MAX,MAX,MAX},
                {10,0,10,8,10,9,MAX,MAX},
                {9,10,0,0,MAX,MAX,MAX,MAX},
                {5,8,9,0,12,13,MAX, MAX},
                {MAX,10,MAX,12,0,6,5,20},
                {MAX,MAX,MAX,9,6,0,9,14},
                {MAX,MAX,MAX,MAX,5,9,0,10},
                {MAX,MAX,MAX,MAX,20,14,10,0}

        };
        prim(map, map.length);
    }

}

运行结果为

image-20200928000541919

4.总结

通过邻接矩阵图表示的简易实现中，找到所有最小权边共需O(V)的运行时间。使用简单的二叉堆与邻接表来表示的话，普里姆算法的运行时间则可缩减为O(ElogV)，其中E为连通图的边数，V为顶点数。如果使用较为复杂的斐波那契堆，则可将运行时间进一步缩短为O(E+VlogV)，这在连通图足够密集时(当E满足Ω(VlogV)条件时)，可较显著地提高运行速度。

各位看官老爷如果你觉得这篇文章有收获就给我点个赞吧!

281599138440_.pic_hd