适用条件

加权连通图

测试所用图

其中，(a) 为原图，圆圈里面是节点的名称，边上的数字是边的权值。由实线连接的点就是集合U，即生成树在生成过程中加入的点。由虚线连接的点中不包含在集合U中的就是集合V-U，即待加入到生成树的点。虚线的变化就是在每次有节点加入集合U时，V-U中的点更新到集合U的最小权值，也是贪心算法的精髓之处。

算法详解

Prim算法又称为加边法，即每次选择最小权值的边加入到生成树中，然后再更新权值，如此反复，保证每次最优来达到最优解。

所用数据结构

typedef struct closedge
{int adjvex;     //最小边在集合U（最小边在当前子树顶点集合中的那个顶点的下标）int lowcost;    //最小边上的权值
};

注：算法中所提到的集合U与集合V-U，可以通过lowcost是否为0进行区分，没必要浪费空间。

初始化

顶点数组下标i	1	2	3	4	5
adjvex	0	0	0	0	0
lowcost	6	1	5	∞	∞
集合U

添加第一条边

顶点数组下标i	0	1	2	3	4	5
adjvex	0	2	2	0	2	2
lowcost	0	5	0	5	6	4
集合U	0,2

可以看到，初始化后，顶点2与集合U(顶点0)之间的距离是最小的。所以，添加顶点2至集合U；接下来进行更新，发现原节点1与集合U（顶点0）之间的距离6>现在节点1与集合U（顶点0、2）之间的距离5，所以进行更新。将adjvex更新为节点1与集合U最小距离时的集合U中顶点，lowcost就是选择的边的权值。

以上的话请读者再仔细阅读一遍，并结合测试所用图来考虑标红的其他部分。下面的表不再赘述。

添加第二条边

顶点数组下标i	0	1	2	3	4	5
adjvex	0	2	2	5	2	5
lowcost	0	5	0	2	6	0
集合U	0,2,5

添加第三条边

顶点数组下标i	0	1	2	3	4	5
adjvex	0	2	2	3	2	5
lowcost	0	5	0	0	6	0
集合U	0,2,5,3

添加第四条边

顶点数组下标i	0	1	2	3	4	5
adjvex	0	1	2	3	1	5
lowcost	0	0	0	0	3	0
集合U	0,2,3,5,1

添加第五条边

顶点数组下标i	0	1	2	3	4	5
adjvex	0	1	2	3	4	5
lowcost	0	0	0	0	0	0
集合U	0,2,3,5,1,4

Prim算法代码

//最小生成树-Prim算法 参数：图G
void Prim(Graph G)
{int v=0;//初始节点closedge C[MaxVerNum];int mincost = 0; //记录最小生成树的各边权值之和//初始化for (int i = 0; i < G.vexnum; i++){C[i].adjvex = v;C[i].lowcost = G.Edge[v][i];}cout << "最小生成树的所有边:"<< endl;//初始化完毕，开始G.vexnum-1次循环for (int i = 1; i < G.vexnum; i++){int k;int min = INF;//求出与集合U权值最小的点 权值为0的代表在集合U中for (int j = 0; j<G.vexnum; j++){if (C[j].lowcost != 0 && C[j].lowcost<min){min = C[j].lowcost;k = j;}}//输出选择的边并累计权值cout << "(" << G.Vex[k] << "," << G.Vex[C[k].adjvex]<<") ";mincost += C[k].lowcost;//更新最小边for (int j = 0; j<G.vexnum; j++){if (C[j].lowcost != 0 && G.Edge[k][j]<C[j].lowcost){   C[j].adjvex = k;C[j].lowcost= G.Edge[k][j];}}}cout << "最小生成树权值之和:" << mincost << endl;
}

全部代码

/*
Project: 图-最小生成树-Prim算法
Date:    2019/11/10
Author:  Frank Yu
基本操作函数:
InitGraph(Graph &G)             初始化函数 参数：图G 作用：初始化图的顶点表，邻接矩阵等
InsertNode(Graph &G,VexType v) 插入点函数 参数：图G,顶点v 作用：在图G中插入顶点v,即改变顶点表
InsertEdge(Graph &G,VexType v,VexType w) 插入边函数 参数：图G,某边两端点v和w 作用：在图G两点v,w之间加入边，即改变邻接矩阵
Adjancent(Graph G,VexType v,VexType w) 判断是否存在边(v,w)函数 参数：图G，某边两端点v和w 作用：判断是否存在边(v,w)
BFS(Graph G, int start) 广度遍历函数 参数：图G,开始结点下标start 作用：宽度遍历
DFS(Graph G, int start) 深度遍历函数（递归形式）参数：图G,开始结点下标start 作用：深度遍历
Dijkstra(Graph G, int v)  最短路径 - Dijkstra算法 参数：图G、源点v
功能实现函数：
CreateGraph(Graph &G) 创建图功能实现函数 参数：图G  InsertNode 作用：创建图
BFSTraverse(Graph G)  广度遍历功能实现函数 参数：图G 作用：宽度遍历
DFSTraverse(Graph G)  深度遍历功能实现函数 参数：图G 作用：深度遍历
Shortest_Dijkstra(Graph &G) 调用最短路径-Dijkstra算法 参数：图G、源点v
Prim(Graph G) 最小生成树-Prim算法 参数：图G
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<string>
#include<set>
#include<list>
#include<queue>
#include<vector>
#include<map>
#include<iterator>
#include<algorithm>
#include<iostream>
#define MaxVerNum 100 //顶点最大数目值
#define VexType char //顶点数据类型
#define EdgeType int //边数据类型,无向图时邻接矩阵对称，有权值时表示权值，没有时1连0不连
#define INF 0x3f3f3f3f//作为最大值
using namespace std;
//图的数据结构
typedef struct Graph
{VexType Vex[MaxVerNum];//顶点表EdgeType Edge[MaxVerNum][MaxVerNum];//边表int vexnum, arcnum;//顶点数、边数
}Graph;
//迪杰斯特拉算法全局变量
bool S[MaxVerNum]; //顶点集
int D[MaxVerNum];  //到各个顶点的最短路径
int Pr[MaxVerNum]; //记录前驱
//Prim算法所用数据结构
typedef struct closedge
{int adjvex;     //最小边在集合U（最小边在当前子树顶点集合中的那个顶点的下标）int lowcost;    //最小边上的权值
};
//*********************************************基本操作函数*****************************************//
//初始化函数 参数：图G 作用：初始化图的顶点表，邻接矩阵等
void InitGraph(Graph &G)
{memset(G.Vex, '#', sizeof(G.Vex));//初始化顶点表//初始化边表for (int i = 0; i < MaxVerNum; i++)for (int j = 0; j < MaxVerNum; j++){G.Edge[i][j] = INF;if (i == j)G.Edge[i][j] = 0;//在最小生成树时，考虑无环简单图,故自己到自己设置为0}G.arcnum = G.vexnum = 0;          //初始化顶点数、边数
}
//插入点函数 参数：图G,顶点v 作用：在图G中插入顶点v,即改变顶点表
bool InsertNode(Graph &G, VexType v)
{if (G.vexnum < MaxVerNum){G.Vex[G.vexnum++] = v;return true;}return false;
}
//插入边函数 参数：图G,某边两端点v和w 作用：在图G两点v,w之间加入边，即改变邻接矩阵
bool InsertEdge(Graph &G, VexType v, VexType w, int weight)
{int p1, p2;//v,w两点下标p1 = p2 = -1;//初始化for (int i = 0; i<G.vexnum; i++)//寻找顶点下标{if (G.Vex[i] == v)p1 = i;if (G.Vex[i] == w)p2 = i;}if (-1 != p1&&-1 != p2)//两点均可在图中找到{G.Edge[p1][p2] = G.Edge[p2][p1] = weight;//无向图邻接矩阵对称G.arcnum++;return true;}return false;
}
//判断是否存在边(v,w)函数 参数：图G，某边两端点v和w 作用：判断是否存在边(v,w)
bool Adjancent(Graph G, VexType v, VexType w)
{int p1, p2;//v,w两点下标p1 = p2 = -1;//初始化for (int i = 0; i<G.vexnum; i++)//寻找顶点下标{if (G.Vex[i] == v)p1 = i;if (G.Vex[i] == w)p2 = i;}if (-1 != p1&&-1 != p2)//两点均可在图中找到{if (G.Edge[p1][p2] == 1)//存在边{return true;}return false;}return false;
}
bool visited[MaxVerNum];//访问标记数组，用于遍历时的标记
//广度遍历函数 参数：图G,开始结点下标start 作用：宽度遍历
void BFS(Graph G, int start)
{queue<int> Q;//辅助队列cout << G.Vex[start];//访问结点visited[start] = true;Q.push(start);//入队while (!Q.empty())//队列非空{int v = Q.front();//得到队头元素Q.pop();//出队for (int j = 0; j<G.vexnum; j++)//邻接点{if (G.Edge[v][j] <INF && !visited[j])//是邻接点且未访问{cout << "->";cout << G.Vex[j];//访问结点visited[j] = true;Q.push(j);//入队}}}//whilecout << endl;
}
//深度遍历函数（递归形式）参数：图G,开始结点下标start 作用：深度遍历
void DFS(Graph G, int start)
{cout << G.Vex[start];//访问visited[start] = true;for (int j = 0; j < G.vexnum; j++){if (G.Edge[start][j] < INF && !visited[j])//是邻接点且未访问{cout << "->";DFS(G, j);//递归深度遍历}}
}
//最短路径 - Dijkstra算法 参数：图G、源点v
void Dijkstra(Graph G, int v)
{//初始化int n = G.vexnum;//n为图的顶点个数for (int i = 0; i < n; i++){S[i] = false;D[i] = G.Edge[v][i];if (D[i] < INF)Pr[i] = v; //v与i连接，v为前驱else Pr[i] = -1;}S[v] = true;D[v] = 0;//初始化结束,求最短路径，并加入S集for (int i = 1; i < n; i++){int min = INF;int temp;for (int w = 0; w < n; w++)if (!S[w] && D[w] < min) //某点temp未加入s集，且为当前最短路径{temp = w;min = D[w];}S[temp] = true;//更新从源点出发至其余点的最短路径 通过tempfor (int w = 0; w < n; w++)if (!S[w] && D[temp] + G.Edge[temp][w] < D[w]){D[w] = D[temp] + G.Edge[temp][w];Pr[w] = temp;}}
}
//输出最短路径
void Path(Graph G, int v)
{if (Pr[v] == -1)return;Path(G, Pr[v]);cout << G.Vex[Pr[v]] << "->";
}
//**********************************************功能实现函数*****************************************//
//打印图的顶点表
void PrintVex(Graph G)
{for (int i = 0; i < G.vexnum; i++){cout << G.Vex[i] << " ";}cout << endl;
}
//打印图的边矩阵
void PrintEdge(Graph G)
{for (int i = 0; i < G.vexnum; i++){for (int j = 0; j < G.vexnum; j++){if (G.Edge[i][j] == INF)cout << "∞ ";else cout << G.Edge[i][j] << " ";}cout << endl;}
}
//创建图功能实现函数 参数：图G  InsertNode 作用：创建图
void CreateGraph(Graph &G)
{VexType v, w;int vn, an;//顶点数，边数cout << "请输入顶点数目:" << endl;cin >> vn;cout << "请输入边数目:" << endl;cin >> an;cout << "请输入所有顶点名称:" << endl;for (int i = 0; i<vn; i++){cin >> v;if (InsertNode(G, v)) continue;//插入点else {cout << "输入错误！" << endl; break;}}cout << "请输入所有边（每行输入边连接的两个顶点及权值）:" << endl;for (int j = 0; j<an; j++){int weight;cin >> v >> w >> weight;if (InsertEdge(G, v, w, weight)) continue;//插入边else {cout << "输入错误！" << endl; break;}}PrintVex(G);PrintEdge(G);
}
//广度遍历功能实现函数 参数：图G 作用：宽度遍历
void BFSTraverse(Graph G)
{for (int i = 0; i<MaxVerNum; i++)//初始化访问标记数组{visited[i] = false;}for (int i = 0; i < G.vexnum; i++)//对每个连通分量进行遍历{if (!visited[i])BFS(G, i);}
}
//深度遍历功能实现函数 参数：图G 作用：深度遍历
void DFSTraverse(Graph G)
{for (int i = 0; i<MaxVerNum; i++)//初始化访问标记数组{visited[i] = false;}for (int i = 0; i < G.vexnum; i++)//对每个连通分量进行遍历{if (!visited[i]){DFS(G, i); cout << endl;}}
}
//调用最短路径-Dijkstra算法 参数：图G、源点v
void Shortest_Dijkstra(Graph &G)
{char vname;int v = -1;cout << "请输入源点名称:" << endl;cin >> vname;for (int i = 0; i < G.vexnum; i++)if (G.Vex[i] == vname)v = i;if (v == -1){cout << "没有找到输入点！" << endl;return;}Dijkstra(G, v);cout << "目标点" << "\t" << "最短路径值" << "\t" << "最短路径" << endl;for (int i = 0; i < G.vexnum; i++){if (i != v){cout << "  " << G.Vex[i] << "\t" << "        " << D[i] << "\t";Path(G, i);cout << G.Vex[i] << endl;}}
}
//最小生成树-Prim算法 参数：图G
void Prim(Graph G)
{int v=0;//初始节点closedge C[MaxVerNum];int mincost = 0; //记录最小生成树的各边权值之和//初始化for (int i = 0; i < G.vexnum; i++){C[i].adjvex = v;C[i].lowcost = G.Edge[v][i];}cout << "最小生成树的所有边:"<< endl;//初始化完毕，开始G.vexnum-1次循环for (int i = 1; i < G.vexnum; i++){int k;int min = INF;//求出与集合U权值最小的点 权值为0的代表在集合U中for (int j = 0; j<G.vexnum; j++){if (C[j].lowcost != 0 && C[j].lowcost<min){min = C[j].lowcost;k = j;}}//输出选择的边并累计权值cout << "(" << G.Vex[k] << "," << G.Vex[C[k].adjvex]<<") ";mincost += C[k].lowcost;//更新最小边for (int j = 0; j<G.vexnum; j++){if (C[j].lowcost != 0 && G.Edge[k][j]<C[j].lowcost){   C[j].adjvex = k;C[j].lowcost= G.Edge[k][j];}}}cout << "最小生成树权值之和:" << mincost << endl;
}
//菜单
void menu()
{cout << "************1.创建图           2.广度遍历******************" << endl;cout << "************3.深度遍历         4.迪杰斯特拉****************" << endl;cout << "************5.最小生成树(Prim) 6.退出      ****************" << endl;
}
//主函数
int main()
{int choice = 0;Graph G;InitGraph(G);while (1){menu();printf("请输入菜单序号：\n");scanf("%d", &choice);if (6 == choice) break;switch (choice){case 1:CreateGraph(G); break;case 2:BFSTraverse(G); break;case 3:DFSTraverse(G); break;case 4:Shortest_Dijkstra(G); break;case 5:Prim(G); break;default:printf("输入错误！！！\n"); break;}}return 0;
}

实验结果

与kruskal算法的对比在这篇文章中：最小生成树-Kruskal算法详解（含全部代码）

更多数据结构与算法实现：数据结构（严蔚敏版）与算法的实现（含全部代码）

有问题请下方评论，转载请注明出处，并附有原文链接，谢谢！如有侵权，请及时联系。

最小生成树-Prim算法详解（含全部代码）相关推荐

相位 unwrap 与 wrap 算法详解（附代码）
相位 unwrap 与 wrap 算法详解(附代码) 最近接手了一个项目,光通信方面的,我负责编写初测结果的数据处理算法,其中有一个算法叫做 unwrap 与 wrap,之前没有听说过.通过询问同事与 ...
kmeans算法详解和python代码实现
kmeans算法详解和python代码实现 kmeans算法无监督学习和监督学习监督学习: 是通过已知类别的样本分类器的参数,来达到所要求性能的过程简单来说,就是让计算机去学习我们已经创建好了的 ...
二分查找算法详解（附代码）
二分查找算法详解(附代码) 注: 现有一个升序不重复的数组查询target是否在此数组中并返回序号使用条件使用二分算法的两个条件: 有序不重复混淆处二分算法两种方式容易弄混淆的地方:就是 ...
AC自动机算法详解以及Java代码实现
详细介绍了AC自动机算法详解以及Java代码实现. 文章目录 1 概念和原理 2 节点定义 3 构建Trie前缀树 3.1 案例演示 4 构建fail失配指针 4.1 案例演示 5 匹配文本 5.1 ...
编辑距离算法详解和python代码
编辑距离(Levenshtein Distance)算法详解和python代码最近做NLP用到了编辑距离,网上学习了很多,看到很多博客写的有问题,这里做一个编辑距离的算法介绍,步骤和多种python ...
基于多相滤波器的数字信道化算法详解(Python, Verilog代码已开源)
基于多相滤波器的数字信道化算法详解推导过程总结仿真本文详细介绍了基于多相滤波器的数字信道化算法的推导过程, 如果您在阅读的过程中发现算法推导过程中有任何错误, 请不吝指出. 此外, 进入我的G ...
敏感词或关键词过滤,DFA算法详解及python代码实现
一.前言近期项目有了一个过滤敏感词的功能需求,在网上找了一些方法及解说,发现DFA算法比较好用,容易实现,但很多文章解释得不太清楚,这里将其详细描述,并用python代码实现. 二.DFA算法详解 ...
paxos算法详解以及模拟代码
0 paxos算法解决了什么问题现在有n个人组成提一个会议,这个会议的目的是为了确定今年的税率,那么每个人都会提出自己认为的今年的合理的税率,为了大家能够达成一致,有了paxos算法.实际里,这个会 ...
hdu 1233 还是畅通工程(最小生成树的Prim和Kruskal两种算法的c++实现)(prim算法详解)...
赤裸裸滴最小生成树(MST),刚学的玩意,用两种方法熟练一下.(都是greedy) Kruskal方法:先对边按照代价非递减排序,再不断添加边且不产生环路,当边数=点数-1结束.判断加入(v,w)是否 ...

最小生成树-Prim算法详解（含全部代码）