克鲁斯卡尔算法

Posted 2023-04-07

在n个城市间建立通信网，只需建立n-1条线路。
利用克鲁斯卡尔算法求网的最小生成树，利用堆排序对边集合先排序。
要利用邻接表建立图的存储结构
谢了啊！我真的不会啊！

你确定要用邻接表吗？因为在克鲁斯卡尔算法里只需要存储边及费用，用邻接表意义不大，还不好排序。
以下给出并查集实现的克鲁斯卡尔算法，求解生成网络的最小费用，并输出生成网络里的路径。
#include<iostream>
#include<algorithm>
using namespace std;
int p[1001],rank[1001];
int cho[1001];
struct edge

int u,v,w;//u表示起始点编号，v表示终点编号，w表示该路径费用
e[15001];
int n,m;//n表示点的个数，m表示路径数
void Init()

int i;
for(i=1;i<=n;i++)

p[i]=i;
rank[i]=0;


bool cmp(edge a,edge b)

return a.w<b.w;

int Find(int t)

if(p[t]!=t)

p[t]=Find(p[t]);

return p[t];

int Union(int a,int b)

int x,y;
x=Find(a);
y=Find(b);
if(rank[x]>rank[y])

p[y]=x;

else

p[x]=y;
if(rank[x]==rank[y])
rank[y]++;

return 0;

int main()

scanf("%d%d",&n,&m);
int i,j;
for(i=0;i<m;i++)

scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);

Init();
sort(e,e+m,cmp);
int cnt=0,ans=0;
for(i=0;i<m;i++)

if(Find(e[i].u)!=Find(e[i].v))

cnt++;
ans+=e[i].w;
Union(e[i].u,e[i].v);
cho[++cho[0]]=i;
if(cnt==n-1)
break;


printf("%d\n",ans);
for(j=1;j<=cho[0];j++)

printf("%d %d\n",e[cho[j]].u,e[cho[j]].v);

return 0;
来自：求助得到的回答 参考技术A 克鲁斯卡尔(Kruskal)算法

typedef struct
VertexType vex1;
VertexType vex2;
VRType weight;
EdgeType;
typedef ElemType EdgeType;
typedef struct // 有向网的定义
VertexType vexs[MAX_VERTEX_NUM]; // 顶点信息
EdgeType edge[MAX_EDGE_NUM]; // 边的信息
int vexnum,arcnum; // 图中顶点的数目和边的数目
ELGraph;

由于克鲁斯卡尔算法是依权值从小到大依次考察每条边，则在本章7.2节中讨论的各种图的表示方法在此都不适用。由此需对图定义一种新的表示方法，以一维数组存放图中所有边，并在构建图的存储结构时将它构造为一个"有序表"。
void MiniSpanTree_Kruskal(ELGraph G, SqList& MSTree)

// G.edge 中依权值从小到大存放有向网中各边，按克鲁斯卡尔
// 算法求得生成树的边存放在顺序表 MSTree 中
MFSet F;
InitSet(F, G.vexnum); // 将森林F初始化为n棵树的集合
InitList(MSTree, G.vexnum); // 初始化生成树为空树
i=0; k=1;
while( k<G.vexnum )
e = G.edge[i]; // 取第 i 条权值最小的边
以顺序表MSTree返回生成树上各条边。
r1 = fix_mfset(F, LocateVex(e.vex1));
r2 = fix_mfset(F, LocateVex(e.vex2)); // 返回两个顶点所在树的树根
if (r1 != r2) // 选定生成树上第k条边
if (ListInsert(MSTree, k, e)) k++; // 插入生成树
mix_mfset(F, r1, r2); // 将两棵树归并为一棵树
// if
i++; // 继续考察下一条权值最小边
// while
DestroySet(F);
// MiniSpanTree_Kruskal

最小生成树 普里姆算法和克鲁斯卡尔算法

基本功能要求：
①输入并存储至少8个顶点14条边的无向图。
②分别编写普里姆算法和克鲁斯卡尔算法，求出最小生成树，输出最小生成树的生成过程。
好的有追分
我要源程序 代码 大牛们

kruskal算法的时间复杂度主要由排序方法决定，其排序算法只与带权边的个数有关，与图中顶点的个数无关，当使用时间复杂度为O（eloge）的排序算法时，克鲁斯卡算法的时间复杂度即为O（eloge），因此当带权图的顶点个数较多而边的条数较少时，使用克鲁斯卡尔算法构造最小生成树效果最好！

克鲁斯卡尔算法
假设 WN=(V,E) 是一个含有 n 个顶点的连通网，则按照克鲁斯卡尔算法构造最小生成树的过程为：先构造一个只含 n 个顶点，而边集为空的子图，若将该子图中各个顶点看成是各棵树上的根结点，则它是一个含有 n 棵树的一个森林。之后，从网的边集 E 中选取一条权值最小的边，若该条边的两个顶点分属不同的树，则将其加入子图，也就是说，将这两个顶点分别所在的两棵树合成一棵树；反之，若该条边的两个顶点已落在同一棵树上，则不可取，而应该取下一条权值最小的边再试之。依次类推，直至森林中只有一棵树，也即子图中含有 n-1条边为止。

普里姆算法
假设 WN=(V,E) 是一个含有 n 个顶点的连通网，TV 是 WN 上最小生成树中顶点的集合，TE 是最小生成树中边的集合。显然，在算法执行结束时，TV=V，而 TE 是 E 的一个子集。在算法开始执行时，TE 为空集，TV 中只有一个顶点，因此，按普里姆算法构造最小生成树的过程为：在所有“其一个顶点已经落在生成树上，而另一个顶点尚未落在生成树上”的边中取一条权值为最小的边，逐条加在生成树上，直至生成树中含有 n-1条边为止。
--以上传自http://hi.baidu.com/valyanprogramming/blog/item/1bc960e6095f9726b93820d9.html

1.Kruskal
//题目地址:http://acm.pku.edu.cn/JudgeOnline/problem?id=1258

#include<cstdio>
#include<cstdlib>
#include<iostream>
using namespace std;
struct node

int v1;
int v2;
int len;
e[10000];//定义边集
int cmp(const void *a,const void *b)//快排比较函数

return ((node*)a)->len-((node*)b)->len;

int v[100],a[100][100];//v为点集
void makeset(int n)

for(int i=0;i<n;i++)
v[i]=i;

int find(int x)

int h=x;
while(h!=v[h])
h=v[h];
return h;

int main()

int n,i,j,r1,r2,p,total;
while(scanf("%d",&n)!=EOF)

p=0;
total=0;
makeset(n);
for(i=0;i<n;i++)

for(j=0;j<n;j++)

scanf("%d",&a[i][j]);
e[p].v1=i;
e[p].v2=j;
e[p].len=a[i][j];
p++;


qsort(e,p,sizeof(e[0]),cmp);
for(i=0;i<p;i++)

r1=find(e[i].v1);
r2=find(e[i].v2);
if(r1!=r2)

total+=e[i].len;
v[r1]=r2;


printf("%d\n",total);

system("pause");
return 0;


2.Prim
//题目地址同上

#include <iostream>
using namespace std;

#define M 101
#define maxnum 100001
int dis[M][M];

int prim(int n)

bool used[M]=;
int d[M],i,j,k;
for(i=1; i<=n; i++)
d[i] = dis[1][i];
used[1] = true;
int sum=0;
for(i=1; i<n; i++)
int temp=maxnum;
for(j=1; j<=n; j++)
if( !used[j] && d[j]<temp )
temp = d[j];
k = j;


used[k] = true;
sum += d[k];
for(j=1; j<=n; j++)
if( !used[j] && dis[k][j]<d[j] )
d[j] = dis[k][j]; // 与Dijksta算法的差别之处


return sum;


int main()

int n,i,j;
while( cin>>n )

for(i=1; i<=n; i++)
for(j=1; j<=n; j++)
scanf("%d",&dis[i][j]);
if( !dis[i][j] )
dis[i][j] = maxnum;



cout<<prim(n)<<endl;

return 0;


代码来自网络 参考技术A #include<stdio.h>
#include<conio.h>
#define N 100
int length;
typedef struct
int num;
int tag;
NODE;
typedef struct
int cost;
int node1;
int node2;
EDGE;
NODE set[N]; /* 节点集, n为连通网的节点数 */
EDGE es[N]; /* 边集, m为连通网的边数 */
EDGE st[N]; /* 最小生成树的边集 */
int InsertSort(EDGE *dat,int n)

int i,item,j,m,h;
for(i=0;i<n;i++)

item=dat[i].cost;
m=dat[i].node1;
h=dat[i].node2;
if(i==0) j=0; dat[j].cost=item;
else

j=i-1;
while((item<dat[j].cost)&&(j>=0))

dat[j+1].cost=dat[j].cost;
dat[j+1].node1=dat[j].node1;
dat[j+1].node2=dat[j].node2;
j--;

dat[j+1].cost=item;
dat[j+1].node1=m;
dat[j+1].node2=h;


printf("权值排序结果(升序)：\n");
for(i=0;i<n;i++) printf("%4d",dat[i].cost);
printf("\n\n");


int Find(NODE *set,int elem)

int i,j,k;
i=elem;
while(set[i].tag>=0) i=set[i].tag;
j=elem;
while(j!=i) k=set[j].tag; set[j].tag=i; j=k;
return i;


int Union( NODE *set,int elem1, int elem2)

int m,n,sum;
m=Find(set,elem1);
n=Find(set,elem2);
sum=set[m].tag+set[n].tag;
if(set[m].tag>set[n].tag) set[n].tag=sum; set[m].tag=n;
else set[m].tag=sum; set[n].tag=m;

int Ququanzhi(EDGE *es,int n)

int i,j=0,len;EDGE b[N];
for(i=0;i<=n;i++)

if(es[i].cost>0)

b[j].cost=es[i].cost;
b[j].node1=es[i].node1;
b[j].node2=es[i].node2;
j++;


len=j;
printf("\n");
for(i=0;i<len;i++)

es[i].cost=b[i].cost;
es[i].node1=b[i].node1;
es[i].node2=b[i].node2;
printf("\n");
return len;


int Kruskal(EDGE *es, NODE *set, int length, EDGE *st,int num)

int i,j,k=1,m,n,mincost=0;
st[0].cost=es[0].cost;
st[0].node1=es[0].node1;
st[0].node2=es[0].node2;
m=Find(set,st[0].node1);
n=Find(set,st[0].node2);
Union(set,m,n);
mincost+=es[0].cost;
for(i=1;i<length;i++) /*找其他边*/

m=Find(set,es[i].node1);
n=Find(set,es[i].node2);
if(m!=n)

Union(set,m,n);
st[k].cost=es[i].cost;
st[k].node1=es[i].node1;
st[k].node2=es[i].node2;
mincost+=es[i].cost;
k++;

if(k==num) break;

printf("\n最小权值边和：mincost=%d\n",mincost);
printf("\n最小树的边数：%d\n\n",k);
return k;


void Output(EDGE *st, int n)

int i;
printf("最小生成树的为：\n\n");
for(i=0;i<n;i++)

printf("树边%d :%3d<-->%d=%d\n",i+1,st[i].node1+1,st[i].node2+1,st[i].cost);



int main()

int i,j,k=0,L,temp,len;NODE *p,*q;
textbackground(BLUE);
textcolor(YELLOW);
system( "graftabl 935 ");/*显示中文必须的代码*/
clrscr();
printf("请输入结点个数：");
scanf("%d",&length);
for(i=0;i<length;i++) set[i].num=i; set[i].tag=-1;
printf("请输入边的权值，若不相邻则输入-1\n");
for(i=0;i<length;i++)

for(j=i+1;j<length;j++)
printf("边：%d<-->%d=",i+1,j+1);
scanf("%d",&es[k].cost);
es[k].node1=i;
es[k].node2=j;
k++;


temp=k;
L=Ququanzhi(es,temp);/*提出权值大于0的边数*/
InsertSort(es,L); /*将权值递增排列*/
printf("\n");
len=Kruskal(es,set,L,st,length-1);
Output(st,len);
printf("\n树的表示：\n");
for(i=0;i<length;i++)
printf("set[%d].num=%d set[%d].tag=%d\n",i,set[i].num+1,i,set[i].tag);

getch();