最小生成树--Prim和Kruskal算法

代码依据书上的例子写出来的,<<数据结构与算法分析C++描述>>Mark Allen Weiss著,张怀勇译

Prim算法:

#include<iostream>
#include<vector>
using namespace std;
const int INF=0xfffffff;
struct mark{
bool known;
int dv;
int pv;

mark(){
dv=INF;
pv=INF;
known=false;
}
};
int main(){
int graph[7][7]={{0,2,4,1,0,0,0},
{2,0,0,3,10,0,0},
{4,0,0,2,0,5,0},
{1,3,2,0,7,8,4},
{0,10,0,7,0,0,6},
{0,0,5,8,0,0,1},
{0,0,0,4,6,1,0}};

vector<mark> table(7);
table[0].dv=0;		//随便从一个节点开始,这里从第01个节点开始
table[0].pv=-1;
//v1声明为已知
while(1){
int i;
int mindv=INF;
int mindex=INF;
//从表中找到dv最小的
for(i=0;i<7;i++){
if(table[i].known==false){
if(table[i].dv<mindv){
mindv=table[i].dv;
mindex=i;
}
}
}
if(mindv==INF)		//已经发现全部节点,退出while
break;
table[mindex].known=true;		//将dv最小的声明为known
//遍历与刚声明的节点相领的且未知的节点,修改其dv和pv
for(i=0;i<7;i++){
if(table[i].known==false){
if(graph[mindex][i]>0 && graph[mindex][i]<table[i].dv){
table[i].dv=graph[mindex][i];
table[i].pv=mindex;
}
}
}
}
cout<<"dv\tpv"<<endl;
for(int i=0;i<7;i++){
cout<<table[i].dv<<"\t"<<table[i].pv+1<<endl;
}

return 0;
}

外层while循环是7次,内层两个for循环,长度都是7.运行时间是O(V^2),这对于稠密图来说是最优的.使用二叉堆时运行时间是O(ElogV),对于稀疏图是一个好的界.

注意这个关系:E=O(V^2),对于稀疏图,情况不会这么差.

下面的

Kruskal算法是本次的重点,因为它采用了更优化的结构,用到了优先队列(也就是堆)和不相交集.

Kruskal是贪心地连续查找权重最小的边,只要不构成回路.

下面代码中用到的DisjSets类在我的这篇博客中已给出http://www.cnblogs.com/zhangchaoyang/articles/1999458.html

下面代码还会涉及到STL中的优先队列,如果你不清楚

priority_queue的用法,建议先看一下http://hi.baidu.com/motioo/blog/item/217ec0253763a36334a80fb3.html

#include"DisjSets.h"
#include<iostream>
#include<functional>
#include<vector>
#include<string>
#include<queue>
using namespace std;
struct edge_weight{
int id;
int weight;
edge_weight(){
}
edge_weight(int id,int weight){
this->id=id;
this->weight=weight;
}
bool operator< (const edge_weight& obj)const{
return weight > obj.weight;
}
};
class cmp{
public:
bool operator()(const edge_weight & n1,const edge_weight & n2)const{
return n1<n2;
}
};
struct edge_ends{
int end1;
int end2;
edge_ends(){
}
edge_ends(int a,int b){
end1=a;
end2=b;
}
};
int main(){
/**录入初始条件**/
//录入边的权重,同时把边放入二叉堆中
//priority_queue<edge_weight,vector<edge_weight>,greater<vector<edge_weight>::value_type> > minQP;
priority_queue<edge_weight,vector<edge_weight>,cmp> minQP;
minQP.push(edge_weight(0,2));		minQP.push(edge_weight(1,4));		minQP.push(edge_weight(2,1));
minQP.push(edge_weight(3,3));		minQP.push(edge_weight(4,10));		minQP.push(edge_weight(5,2));
minQP.push(edge_weight(6,5));		minQP.push(edge_weight(7,7));		minQP.push(edge_weight(8,8));
minQP.push(edge_weight(9,4));		minQP.push(edge_weight(10,6));		minQP.push(edge_weight(11,1));
//录入每条边对应的两个端点
vector<edge_ends> vec;
vec.push_back(edge_ends(1,2));		vec.push_back(edge_ends(1,3));		vec.push_back(edge_ends(1,4));
vec.push_back(edge_ends(2,4));		vec.push_back(edge_ends(2,5));		vec.push_back(edge_ends(3,4));
vec.push_back(edge_ends(3,6));		vec.push_back(edge_ends(4,5));		vec.push_back(edge_ends(4,6));
vec.push_back(edge_ends(4,7));		vec.push_back(edge_ends(5,7));		vec.push_back(edge_ends(6,7));

/**算法的初始状态**/
int edgeAccepted=0;		//已接受的边的个数为0
vector<int> EAP;		//已接受的边的id放入EAP中
DisjSets ds(7);			//最初7个顶点在7个不相交的集合中

/**kruskal核心代码**/
while(edgeAccepted<7-1){
edge_weight minEdg=minQP.top();			//贪婪做法,找出剩余边中权重最小的
minQP.pop();
int index=minEdg.id;
//最小边对应的两个顶点分别是u和v
int u=vec.at(index).end1;
int v=vec.at(index).end2;
//顶点编号是从1开始的,而我们不相交集类中要求元素编号从0开始,所以这里顶点号要-1
int root1=ds.find(u-1);
int root2=ds.find(v-1);
if(root1!=root2){			//两个顶点在不相交集中
EAP.push_back(index);
edgeAccepted++;
ds.unionSets(root1,root2);
}
}

/**打印结果**/
cout<<"最小生成树由下列顶点和它们之间的边组成:"<<endl;
cout<<"顶点1\t顶点2"<<endl;
vector<int>::iterator itr=EAP.begin();
while(itr!=EAP.end()){
int i=*itr;
cout<<vec[i].end1<<"\t"<<vec[i].end2<<endl;
++itr;
}

return 0;
}