最小生成树的创建（Prime普利姆算法、java实现）

已于 2022-03-05 20:39:39 修改
阅读量1.7k 收藏 21
点赞数 6
分类专栏： 学习非日记 文章标签： 算法 java 图论 二叉树 数据结构
于 2021-12-22 10:54:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52939031/article/details/122069495
版权

文章目录

前言

要在n个城市之间铺设光缆，主要目标是要使这 n 个城市的任意两个之间都可以通信，我们可以选择将n个城市当成n个节点，然后将所有的节点相连接形成一个连通图，边上的数字代表与边相邻的两座城市之间铺设光纤的费用（权），但铺设光缆的费用很高，且各个城市之间铺设光缆的费用不同，因此另一个目标是要使铺设光缆的总费用最低。这就需要找到带权的最小生成树。

下面我们就将 A B C D E F G五座城市形成的带权连通图通过prim算法转换成最小生成树。

图1 五个城市形成的带权连通图,两个节点边上的数字代表铺设光纤的费用（权），没有表面数字的边表示与这条边关联的两个城市之间无法直接相通。
在这里插入图片描述

提示：以下是本篇文章正文内容，下面案例可供参考

一、什么是最小生成树？

一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。

在一给定的无向图G = (V, E) 中，(u, v) 代表连接顶点 u 与顶点 v 的边（即），而 w(u, v) 代表此边的权重，若存在 T 为 E 的子集（即）且为无循环图，使得
在这里插入图片描述

** w(T) 最小，则此 T 为 G 的最小生成树。**

例如图1 (A,B)代表连接顶点A与顶点B的边 w(A,B) = 5
规定T为无循环图是因为书的

最小生成树其实是最小权重生成树的简称。

二、Prime算法简述

普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex (graph theory)），且其所有边的权值之和亦为最小。

1.文字描述

1).输入：一个加权连通图，其中顶点集合为V，边集合为E；
图1中
顶点集合V = {A.B,C,D,E,F,G}
边集合E = {（A,B),(B,D),(D,F),(F,E),(E,C),(C,A),(A,G),(B,G),(F,G),(E,G)}

2).初始化：Vnew= {x}，其中x为集合V中的任一节点（起始点），Enew= {},为空；
这里以A节点为起始点
Vnew = {A}

3).重复下列操作，直到Vnew= V：
相等的意思是 原顶点V集合的全部节点经过下面你的操作全部加入到了新的节点集合Vnew中，这样每个节点找到的与之相连的节点形成的边满足权值最小。

a.在集合E中选取权值最小的边<u, v>，其中u为集合Vnew中的元素，而v不在Vnew集合当中，并且
v∈V（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之一）；

第一步：刚开始集合Vnew中只有一个节点A，现在我们要做的是，在V集合中寻找除了A节点以外的其他与A直接连接的节点（除A以外是因为节点A已经存在与Vnew集合之中），满足条件的节点有节点B,C,G。现在我们要对节点A与这三个节点形成的边的权值进行判断，选出权值最小的。w(A,C) = 7,w(A,G) = 2, w(A,B) = 5 显而易见，其中G节点与A节点形成的边的权值最小。

第二步：现在集合Vnew = {A,G}，在集合V中除了A，G节点意外直接与这两个节点相连接的节点有B,C,E,B,F。 w(A,C) = 7,w(A,B) = 5,w(G,E) = 4,w(G,F) = 6,w(G,B) = 3,能够看出G节点与B节点形成的边权值最小。

第三步：现在集合Vnew = {A,G,B},满足条件的节点有C,E,F,D。w(A,C) = 7,w(G,E) = 4, w(G,F) = 6,w(B,D) = 9,这里G节点与E节点形成的边的权值最小。

第四步：现在集合Vnew = {A,G,B,E} , w(E,F) = 5 通过判断 E节点与F节点形成的边的权值最小。

第五步：集合Vnew = {A,G,B,E,F), w(F,D) = 4 最小

第六步：集合Vnew = {A,G,B,E,F,D), w(A,C) = 7 最小

b.将v加入集合Vnew中，将<u, v>边加入集合Enew中；

第一步： 将G节点加入到集合Vnew中，w(A,G)边加入到集合Enew中

第二步：将B节点加入到集合Vnew中，w(G,B)边加入到集合Enew中

第三步：将E节点添加到集合Vnew中，w(G,E)边加入到集合Enew中

第四步：将F节点添加到集合Vnew中，w(E,F)边加入到集合Enew中

第五步：将D节点添加到集合Vnew中，w(F,D)边加入到集合Enew中

第六步：将A节点添加到集合Vnew中，w(A,C)边加入到集合Enew中
到目前为止：
Vnew = {A,G,B,E,F,D,A}
Enew = {(A,G),(G,B),(G,E),(E,F),(F,D),(F,D),(A,C)}

2.图文演示

3).重复下列操作，直到Vnew= V：
相等的意思是 原顶点V集合的全部节点经过下面你的操作全部加入到了新的节点集合Vnew中，这样每个节点找到的与之相连的节点形成的边满足权值最小。

a.在集合E中选取权值最小的边<u, v>，其中u为集合Vnew中的元素，而v不在Vnew集合当中，并且
v∈V（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之一）；

第一步：刚开始集合Vnew中只有一个节点A，

现在我们要做的是，在V集合中寻找除了A节点以外的其他与A直接连接的节点（除A以外是因为节点A已经存在与Vnew集合之中），
满足条件的节点有节点B,C,G。
在这里插入图片描述

现在我们要对节点A与这三个节点形成的边的权值进行判断，选出权值最小的。w(A,C) = 7,w(A,G) = 2, w(A,B) = 5
显而易见，其中G节点与A节点形成的边的权值最小。

第二步：现在集合Vnew = {A,G}，

在集合V中除了A，G节点意外直接与这两个节点相连接的节点有B,C,E,F。
在这里插入图片描述

w(A,C) = 7,w(A,B) = 5,w(G,E) = 4,w(G,F) = 6,w(G,B) = 3,
能够看出G节点与B节点形成的边权值最小。

第三步：现在集合Vnew = {A,G,B},

满足条件的节点有C,E,F,D。
在这里插入图片描述

w(A,C) = 7,w(G,E) = 4, w(G,F) = 6,w(B,D) = 9,这里G节点与E节点形成的边的权值最小。

第四步：现在集合Vnew = {A,G,B,E} ,
满足条件的节点有C,D,F
在这里插入图片描述

w(E,F) = 5 通过判断 E节点与F节点形成的边的权值最小。

第五步：集合Vnew = {A,G,B,E,F),
满足条件的节点有C,D
在这里插入图片描述
w(F,D) = 4 最小

第六步：集合Vnew = {A,G,B,E,F,D),
满足条件的节点有C
在这里插入图片描述
w(A,C) = 7 最小

第七步：
在这里插入图片描述
通过上述步骤 我们得到的Enew集合中含有六条边分别是(A,C),(A,G),(G,B),(G,E),(E,F),(F,D)

形成的最小二叉树如下图
在这里插入图片描述
整理过后如下
在这里插入图片描述

三、代码实现

1.节点代码

class MGraph {
    int nodes; //节点的个数
    char[] element; //节点的元素
    int[][] side; //存放边，邻接矩阵

    public MGraph(int nodes) { //构造器
        this.nodes = nodes;
        element = new char[nodes];
        side = new int[nodes][nodes];
    }
}

2.邻接矩阵

我们通过邻接矩阵来实现各个城市之间的连通图

int[][] side = {
                {10000, 5, 7, 10000, 10000, 10000, 2},
                {5, 10000, 10000, 9, 10000, 10000, 3},
                {7, 10000, 10000, 10000, 8, 10000, 10000},
                {10000, 9, 10000, 10000, 10000, 4, 10000},
                {10000, 10000, 8, 10000, 10000, 5, 4},
                {10000, 10000, 10000, 4, 5, 10000, 6},
                {2, 3, 10000, 10000, 4, 6, 10000}};

其中，数字10000代表两个城市之间不相直接连通

如图
在这里插入图片描述

3.将邻接矩阵形成连通图

 //创建树
    public void creatTree(MGraph mGraph, int nodes, char[] element, int[][] side) {
        for (int i = 0; i < nodes; i++) {
            mGraph.element[i] = element[i]; //添加每个顶点的名字
            for (int j = 0; j < nodes; j++) {
                mGraph.side[i][j] = side[i][j]; //添加各个城市之间直接相连的边的权值
            }
        }
    }

4.Prime算法

 //普利姆算法
    public void prim(MGraph mGraph, int node) {
        int[] nodes = new int[mGraph.nodes]; //用于标记遍历过的节点
         nodes[node] = 1; //将当前节点标记为1 表示已访问
        //用来记录最小路径两个节点的下标
        int index1 = -1;
        int index2 = -1;
        int minSide = 10000; //遍历与之比较 找到最小的路径

        for (int k = 1; k < mGraph.nodes; k++) { //若有n个节点 则有n - 1 条边
            for (int i = 0; i < mGraph.nodes; i++) {
                for (int j = 0; j < mGraph.nodes; j++) {
                    if (nodes[i] == 1 && nodes[j] == 0 && mGraph.side[i][j] < minSide) {
                  //      代表在已经访问过的节点中(即本博客上文写到已经加入到Vnew集合中的节点） 遍历 未访问过的节点（即满足条件的节点） 并 找到最小的路径 将其返回
                        minSide = mGraph.side[i][j]; //最短边上的权值
                        //最短边的两个顶点
                        index1 = i;
                        index2 = j;
                    }
                }
            }
            //从第内层for循环出来后，表示找到一条最短边
            System.out.println("边<" + mGraph.element[index1] + "," + mGraph.element[index2] + ">权值：" + minSide);
            nodes[index2] = 1; //将最内层与已访问节点路径最短的节点设置为已访问 （将找出的节点添加到Vnew集合中）
            minSide = 10000; //将minSide恢复初始值 开始下次遍历
        }
    }

5.完整代码

package com.xx.prime;

public class PrimAlgorithm {

    public static void main(String[] args) {
        char[] element = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        int nodes = element.length;
        int[][] side = {
                {10000, 5, 7, 10000, 10000, 10000, 2},
                {5, 10000, 10000, 9, 10000, 10000, 3},
                {7, 10000, 10000, 10000, 8, 10000, 10000},
                {10000, 9, 10000, 10000, 10000, 4, 10000},
                {10000, 10000, 8, 10000, 10000, 5, 4},
                {10000, 10000, 10000, 4, 5, 10000, 6},
                {2, 3, 10000, 10000, 4, 6, 10000}};

        MGraph mGraph = new MGraph(nodes);
        MinTree minTree = new MinTree();
        minTree.creatTree(mGraph, nodes, element, side);
        minTree.showTree(mGraph);
        minTree.prim(mGraph, 0);
    }
}

class MinTree {

    //创建树
    public void creatTree(MGraph mGraph, int nodes, char[] element, int[][] side) {
        for (int i = 0; i < nodes; i++) {
            mGraph.element[i] = element[i];
            for (int j = 0; j < nodes; j++) {
                mGraph.side[i][j] = side[i][j];
            }
        }
    }

    //普利姆算法
    public void prim(MGraph mGraph, int node) {
        int[] nodes = new int[mGraph.nodes]; //用于标记遍历过的节点
         nodes[node] = 1; //将当前节点标记为1 表示已访问
        //用来记录最小路径两个节点的下标
        int index1 = -1;
        int index2 = -1;
        int minSide = 10000; //遍历与之比较 找到最小的路径

        for (int k = 1; k < mGraph.nodes; k++) { //若有n个节点 则有n - 1 条边
            for (int i = 0; i < mGraph.nodes; i++) {
                for (int j = 0; j < mGraph.nodes; j++) {
                    if (nodes[i] == 1 && nodes[j] == 0 && mGraph.side[i][j] < minSide) {
                  //      代表在已经访问过的节点中(即本博客上文写到已经加入到Vnew集合中的节点） 遍历 未访问过的节点（即满足条件的节点） 并 找到最小的路径 将其返回
                        minSide = mGraph.side[i][j]; //最短边上的权值
                        //最短边的两个顶点
                        index1 = i;
                        index2 = j;
                    }
                }
            }
            //从第内层for循环出来后，表示找到一条最短边
            System.out.println("边<" + mGraph.element[index1] + "," + mGraph.element[index2] + ">权值：" + minSide);
            nodes[index2] = 1; //将最内层与已访问节点路径最短的节点设置为已访问 （将找出的节点添加到Vnew集合中）
            minSide = 10000; //将minSide恢复初始值 开始下次遍历
        }
    }

    //输出树
    public void showTree(MGraph mGraph) {
        for (int[] arr : mGraph.side) {
            for (int element : arr) {
                System.out.print(element + " ");
            }
            System.out.println();
        }

    }
}

class MGraph {
    int nodes; //节点的个数
    char[] element; //节点的元素
    int[][] side; //存放边，邻接矩阵

    public MGraph(int nodes) { //构造器
        this.nodes = nodes;
        element = new char[nodes];
        side = new int[nodes][nodes];
    }
}

6.输出结果

在这里插入图片描述

bueee
关注
  • 6
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
最小生成二叉树-prim算法
weixin_33937913的博客
05-25 1167
1.prim算法：一种计算生成最小生成树的方法，它的每一步都会为一棵生长中的树添加一条边. 2.时间复杂度： 通过邻接矩阵图表示的简易实现中，找到所有最小权边共需O（V）的运行时间。使用简单的二叉堆与邻接表来表示的话，普里姆算法的运行时间则可缩减为 O(ElogV)，其中E为连通图的边数，V为顶点数。如果使用较为复杂的斐波那契堆，则可将运行时间进一步缩短为O(E+VlogV)，这在...
Prim(普里姆)算法生成图的最小生成树（C++）
smart_jackli的博客
11-18 2942
Prim算法的实现
最小生成树的普利姆prim算法代码实现
m0_73641819的博客
11-20 303
【代码】最小生成树的普利姆prim算法代码实现。
【最小生成树】—— Kruskal算法(C++详解版) 思路分析 & 代码实现
H13420972436的博客
05-19 908
关于”判断是否形成环路“的阐释 在实现过程中，通常会使用并查集来判断是否形成环路。如果选中的边的两个顶点属于同一个集合，则说明会形成环路，此时应该舍弃该边。否则，将两个顶点合并到同一个集合中，并将该边加入最小生成树中。
数据结构---最小生成树（(普里姆算法)C语言看了就懂教程）
m0_56499257的博客
06-17 3565
通过普里姆算法，找到连通城市网络所需要付出的最小代价的方法，就需要将城市网转换成最小生成树。
最小生成树之prime算法
2301_76371717的博客
03-03 557
最小生成树：无向图中，所有边权之和最小的树。
Python采用Prim(普利姆)算法实现最小生成树
最新发布
05-25
最小生成树（Minimum Spanning Tree, MST） 最小生成树是一个无向加权连通图的子集，它连接了图中的所有顶点（节点），并且没有循环（回路），同时所有边的权重之和是最小的。在计算机网络、电路设计、物流运输等...
Java语言实现使用Prim（普利姆）算法求最小生成树（源代码）
05-15
1. 初始化：创建一个空的最小生成树，并选择图中的任意一个顶点作为起始点，将其加入最小生成树中。 2. 对于不在最小生成树中的每个顶点，计算它与最小生成树中所有顶点的边的权重，并保存最小权重及其对应的顶点。 ...
C语言求最小生成树 普利姆算法（贪心思想）
01-25
在G的所有生成树中，耗费最小的生成树称为G的最小生成树。 贪心选择策略： 每次都选择到下一顶点权最小的边。 基本步骤： 1.置顶点集合S={1}； 2.只要S是V的真子集，就作如下的贪心选择：选取满足条件i∈S，j∈V...
C++语言实现使用Prim（普利姆）算法求最小生成树
12-24
Prim算法是一种求解最小生成树问题的贪心算法。其基本原理是：每次从未被选择的顶点中选择一个距离当前生成树最近的顶点加入生成树，直到所有的顶点都被选择。 以下是Prim算法的详细步骤： 初始化：选取图中的任一...
C实现最小生成树（普利姆算法）
06-03
本文将深入探讨如何使用C语言实现普利姆算法来构建最小生成树。 普利姆算法是一种贪心策略，它的基本思想是从一个顶点开始，逐步增加边，每次添加一条与当前树形成最小权值边的边，直到连接所有顶点。以下为普利姆...
Prime算法 图
08-27
选择合适的存储结构表示一个图，并实现下列运算要求： （1）构造一个带权值的图。 （2）根据图求解Prime算法，其基本思想是：从指定定点开始作为起点，然后反复在满足如下条件的边中选择一条最小边，直到所有顶点成为已选顶点为止（选择n-1条边）。满足的条件是：一端已选，一端未选。
用Java利用prim算法实现最小生成树
12-14
标题： 最小生成树 时 限： 1000 ms 内存限制： 10000 K 总时限： 3000 ms 描述： 有一张城市地图，图中的顶点为城市，无向边代表两个城市间的连通关系，边上的权为在这两个城市之间修建高速公路的造价，研究后发现，这个地图有一个特点，即任一对城市都是连通的。现在的问题是，要修建若干高速公路把所有城市联系起来，问如何设计可使得工程的总造价最少。假定所有输入的根节点或者源为第一个城市或第一组数据。 请使用prim算法求解。 输入： n（城市数，1<=n<=100）； e（边数）； 以下e行，每行3个数i,j,wij，表示在城市i,j之间修建高速公路的造价。 输出： n-1行，每行为两个城市的序号，表明这两个城市间建一条高速公路。 输入样例： 5 8 1 2 2 1 3 12 1 4 10 2 3 8 2 5 9 3 4 6 3 5 3 4 5 7 输出样例： 1 2 2 3 3 5 3 4
【最小生成树模型】
武帝为此的博客
06-01 1557
最小生成树（Minimum Spanning Tree，简称MST）是图论中的经典问题之一，它在实际应用中有着广泛的应用。本文将介绍最小生成树模型的原理和应用，并通过一个实战项目来演示如何使用Python实现最小生成树算法。
Prime 算法
Pandora_heart的博客
08-01 6689
- 算法 -
图算法总结---Prime算法
硕鼠的博客
03-18 1201
// // Created by liyuanshuo on 2017/3/13. // #include const int max_cost = 0x7fffffff; //int graph[10010][10010]; int prime(int graph[][10010], int n) { int lowcost[10010]; int mst[10010]; int
最小生成树详细讲解（Prime算法+Kruskalsuanfa）
innocence的博客
04-17 1万+
生成树 一个连通图（如果图中任意两点都是连通的，那么图被称作连通图。如果此图是有向图，则称为强连通图（注意：需要双向都有路径））的生成树是该连通图的一个极小连同子图,它含有图中全部顶点,和构成一棵树的(n-1)条边.如果在一棵生成树上添加任何一条边,必定构成一个环,因为这条边使得它依附的那两个顶点之间有了第二条路径.一棵有n个顶点的生成树(连通无回路图)有且仅有(n-1)条边,但是...
prime算法详解【最小生成树】
热门推荐
二喵君的博客
11-04 2万+
无以言表我对着代码懵了两个小时终于看懂了的鸡冻，手写程序大法好哇，【或者只是我太久没敲代码了。。】个人感觉这个算法还是有点粗鲁，大量的遍历，比较中意最小生成树的另一个算法，一会搞懂它的代码再说。 最小生成树：     图G是树当且仅当以下任意条件成立：            1》G有|V|-1条边，无环；【v为图中节点数目】            2》G有|V|-1条边，连通；     ...
prime算法解决最小生成树
fuzekun的博客
10-26 975
1.最小生成树 prime算法 prime算法又称为加点法，循环n次，每次找到距离集合最小距离的点，将它加入集合中。 3.代码 int prime() { memset(dis, 0x3f, sizeof(dis)); int res = 0; for (int i = 0; i < n; i++) { int t = -1; for (int j = 1; j <= n; j ++) { if (!.
普利姆算法最小生成树
12-08
普利姆算法是一种用于求解无向图的最小生成树的基本算法。它以一个起始节点开始，每次将一个未被访问的节点加入到最小生成树集合中，并选择与该集合相邻的边中权重最小的边和它连接的未访问节点，直到最小生成树集合...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值