在边赋权图中,权值总和最小的生成树称为最小生成树。构造最小生成树有两种算法,分别是prim算法和kruskal算法。在边赋权图中,如下图所示:

  java实现最小生成树的prim算法和kruskal算法

在上述赋权图中,可以看到图的顶点编号和顶点之间邻接边的权值,若要以上图来构建最小生成树。结果应该如下所示:

  java实现最小生成树的prim算法和kruskal算法

这样构建的最小生成树的权值总和最小,为17

 

在构建最小生成树中,一般有两种算法,prim算法和kruskal算法

在prim算法中,通过加入最小邻接边的方法来建立最小生成树算法。首先构造一个零图,在选一个初始顶点加入到新集合中,然后分别在原先的顶点集合中抽取一个顶点,使得构成的边为权值最小,然后将该笔边加入到图中,并将抽出的顶点加入到新集合中,重复这个过程,知道新集合等于原先的集合。

 

代码一:(java) 

 1 /**
 2  * 最小生成树的prim算法
 3  * @author liuy
 4  */
 5 public class Prim {
 6     
 7     public static void prim(int num, float[][] weight) {  //num为顶点数,weight为权
 8         float[] lowcost = new float[num + 1];  //到新集合的最小权
 9         
10         int[] closest = new int[num + 1];  //代表与s集合相连的最小权边的点
11         
12         boolean[] s = new boolean[num + 1];  //s[i] == true代表i点在s集合中
13         
14         s[1] = true;  //将第一个点放入s集合
15         
16         for(int i = 2; i <= num; i++) {  //初始化辅助数组
17             lowcost[i] = weight[1][i];
18             closest[i] = 1;
19             s[i] = false;
20         }
21         
22         for(int i = 1; i < num; i++) {
23             float min = Float.MAX_VALUE;
24             int j = 1;
25             for(int k = 2; k <= num; k++) {
26                 if((lowcost[k] < min) && (!s[k])) {//根据最小权加入新点
27                     min = lowcost[k];
28                     j = k;
29                 }
30             }
31             
32             System.out.println("加入点" + j + ". " + j + "---" + closest[j]);//新加入点的j和与j相连的点
33             
34             s[j] = true;//加入新点j
35             
36             for(int k = 2; k <= num; k++) {
37                 if((weight[j][k] < lowcost[k]) && !s[k]) {//根据新加入的点j,求得最小权
38                     lowcost[k] = weight[j][k];
39                     closest[k] = j;
40                 }
41             }
42         }
43     }
44     
45     public static void main(String[] args) {
46         //47         //            /  |  /
48         //           6   1   5
49         //          /    |    /
50         //        ②-5--③--5--④
51         //         /    //    /
52         //          3  6  4  2
53         //           //    //
54         //           ⑤--6-⑥
55         //最小生成树为:
56         //57         //               |   
58         //               1    
59         //               |     
60         //        ②-5--③        ④
61         //         /     /    /
62         //          3     4  2
63         //           /     //
64         //           ⑤        ⑥
65         //
66         float m = Float.MAX_VALUE;
67         float[][] weight = {{0, 0, 0, 0, 0, 0, 0},
68                             {0, m, 6, 1, 5, m, m},
69                             {0, 6, m, 5, m, 3, m},
70                             {0, 1, 5, m, 5, 6, 4},
71                             {0, 5, m, 5, m, m, 2},
72                             {0, m, 3, 6, m, m, 6},
73                             {0, m, m, 4, 2, 6, m}};//上图的矩阵
74         prim(weight.length - 1, weight);
75         //加入点3. 3---1
76         //加入点6. 6---3
77         //加入点4. 4---6
78         //加入点2. 2---3
79         //加入点5. 5---2
80     }
81 }
View Code

相关文章:

  • 2021-10-02
  • 2021-04-18
猜你喜欢
  • 2022-12-23
  • 2022-12-23
  • 2021-08-05
  • 2021-11-18
  • 2021-09-09
  • 2021-08-01
相关资源
相似解决方案