图的存贮结构采用邻接矩阵.此方法是按各个顶点连通的步骤进行,需要用一个顶点集合,开始为空集,以后将以连通的顶点陆续加入到集合中,全部顶点加入集合后就得到所需的最小生成树 .
思路：设图G顶点集合为U，首先任意选择图G中的一点作为起始点a，将该点加入集合V，再从集合U-V中找到另一点b使得点b到V中任意一点的权值最小，此时将b点也加入集合V；以此类推，现在的集合V={a，b}，再从集合U-V中找到另一点c使得点c到V中任意一点的权值最小，此时将c点加入集合V，直至所有顶点全部被加入V，此时就构建出了一颗MST。因为有N个顶点，所以该MST就有N-1条边，每一次向集合V中加入一个点，就意味着找到一条MST的边。
#include<iostream> #include<limits.h> #define Max INT_MAX using namespace std; int gp[110][110]; int Prim(int n) { int lowcost[110]; //表示终点的边的最小权值 int adjvex[110]; //标记数组，判断节点是否遍历 int sum=0; //统计总路线 int i,j,k,min,minid; for( i=1; i<=n; i++) //从节点1开始 { lowcost[i]=gp[1][i]; adjvex[i]=0; } adjvex[1]=1; for(i=1; i<n; i++) { min=Max; minid=0; for(j=2; j<=n; j++) { if(!adjvex[j]&&lowcost[j]<min) { min=lowcost[j]; minid=j; //存储当前最小值的下标 } } sum+=min; adjvex[minid]=1; for(j=2; j<=n; j++) { if(!adjvex[j]&&gp[minid][j]<lowcost[j]) { lowcost[j]=gp[minid][j]; //更新lowcost数组 } } } for(int i=1; i<=n; i++) //判断是否连通 { if(!adjvex[i]) { sum=-1; break; } } return sum; } int main() { int n,m; while(cin>>n>>m) { for(int i=1; i<=n; i++) // 赋初值 for(int j=1; j<=n; j++) if(i==j) gp[i][j]=0; else gp[i][j]=Max; for(int i=0; i<m; i++) { int a,b,d; cin>>a>>b>>d; if(d<gp[a][b]) //若路径相同，取最小值 { gp[a][b]=d; gp[b][a]=d; } } int s=Prim(n); cout<<s<<endl; } return 0; } 这里不加标记数组也可以： #include<iostream> #include<limits.h> #define Max INT_MAX using namespace std; int gp[110][110]; int Prim(int n) { int lowcost[110]; //表示终点的边的最小权值 int sum=0; //统计总路线 int i,j,k,min,minid; for( i=2; i<=n; i++) //从节点1开始 { lowcost[i]=gp[1][i]; } lowcost[1]=-1; for(i=1; i<n; i++) { min=Max; minid=-1; for(j=2; j<=n; j++) { if(lowcost[j]!=-1&&lowcost[j]<min) { min=lowcost[j]; minid=j; //存储当前最小值的下标 } } sum+=min; lowcost[minid]=-1; for(j=2; j<=n; j++) { if(lowcost[j]!=-1&&gp[minid][j]<lowcost[j]) { lowcost[j]=gp[minid][j]; //更新lowcost数组 } } } for(int i=1; i<=n; i++) //判断是否连通 { if(!lowcost[i]) { sum=-1; break; } } return sum; } int main() { int n,m; while(cin>>n>>m) { for(int i=1; i<=n; i++) // 赋初值 for(int j=1; j<=n; j++) if(i==j) gp[i][j]=0; else gp[i][j]=Max; for(int i=0; i<m; i++) { int a,b,d; cin>>a>>b>>d; if(d<gp[a][b]) //若路径相同，取最小值 { gp[a][b]=d; gp[b][a]=d; } } int s=Prim(n); cout<<s<<endl; } return 0; } Krusal算法：（克鲁斯卡尔算法是直接以边为目标去构建。）
图的存贮结构采用边集数组,且权值相等的边在数组中排列次序可以是任意的.该方法对于边相对比较多的不是很实用,浪费时间.
思路：设无向连通网为G＝(V, E)，令G的最小生成树为T＝(U, TE)，其初态为U＝V，TE＝{ }，然后，按照边的权值由小到大的顺序，考察G的边集E中的各条边。若被考察的边的两个顶点属于T的两个不同的连通分量（并查集），则将此边作为最小生成树的边加入到T中，同时把两个连通分量连接为一个连通分量；若被考察边的两个顶点属于同一个连通分量，则舍去此边，以免造成回路，如此下去，当T中的连通分量个数为1时，此连通分量便为G的一棵最小生成树。
#include<iostream> #include<queue> #include<algorithm> using namespace std; struct node { int b,e,w; }; bool cmp(node x,node y) //比较函数，按权值升序排列 { return x.w<y.w; } int Find(int pre[],int k) //查找函数：查找连通分量顶点 { while(k!=pre[k]) k=pre[k]; return k; } void Kruskal(node g[],int m,int n) { int i,sum=0,cnt=0; int pre[100]; for( i=1; i<=n; i++) pre[i]=i; for( i=0; i<m; i++) { int x=Find(pre,g[i].b); int y=Find(pre,g[i].e); if(x!=y) //不相等，说明不在一个连通分量 { pre[x]=y; //将y加入x的连通分量 sum+=g[i].w; //计算路径 // cout<<g[i].b<<" "<<g[i].e<<" "<<g[i].w<<endl; } } cout <<sum<<endl; } int main() { int n,m; node g[10000]; while(cin>>n>>m) { for(int i=0; i<m; i++) //建立边集数组 { int a,b,d; cin>>a>>b>>d; g[i].b=a; g[i].e=b; g[i].w=d; } sort(g,g+m,cmp); Kruskal(g,m,n); } return 0; }