第1关:算法6.8 prim算法
//算法6.8 普里姆算法
#include <iostream>
using namespace std;
typedef char VerTexType;
typedef int ArcType;
#define MVNum 100
#define MaxInt 32767 //表示极大值,即∞
//辅助数组的定义,用来记录从顶点集U到V-U的权值最小的边
struct edge{
VerTexType adjvex; //最小边在U中的那个顶点
ArcType lowcost; //最小边上的权值
}closedge[MVNum];
//- - - - -图的邻接表存储表示- - - - -
typedef char VerTexType; //假设顶点的数据类型为字符型
typedef int ArcType; //假设边的权值类型为整型
typedef struct{
VerTexType vexs[MVNum]; //顶点表
ArcType arcs[MVNum][MVNum]; //邻接矩阵
int vexnum,arcnum; //图的当前点数和边数
}AMGraph;
int LocateVex(AMGraph G , VerTexType v){
//确定点v在G中的位置
for(int i = 0; i < G.vexnum; ++i)
if(G.vexs[i] == v)
return i;
return -1;
}//LocateVex
void CreateUDN(AMGraph &G){
//采用邻接矩阵表示法,创建无向网G
int i , j , k;
cin >> G.vexnum >> G.arcnum; //输入总顶点数,总边数
for(i = 0; i < G.vexnum; ++i){
cin >> G.vexs[i]; //依次输入点的信息
}
for(i = 0; i < G.vexnum; ++i) //初始化邻接矩阵,边的权值均置为极大值MaxInt
for(j = 0; j < G.vexnum; ++j)
G.arcs[i][j] = MaxInt;
for(k = 0; k < G.arcnum;++k){ //构造邻接矩阵
VerTexType v1 , v2;
ArcType w;
cin >> v1 >> v2 >> w; //输入一条边依附的顶点及权值
i = LocateVex(G, v1); j = LocateVex(G, v2); //确定v1和v2在G中的位置,即顶点数组的下标
G.arcs[i][j] = w; //边<v1, v2>的权值置为w
G.arcs[j][i] = G.arcs[i][j]; //置<v1, v2>的对称边<v2, v1>的权值为w
}//for
}//CreateUDN
int Min(AMGraph G){
//返回权值最小的点
/**************************Begin**********************/
int maxv = MaxInt;
int k = 0;
for(int i = 0;i < G.vexnum;i ++ )
if(closedge[i].lowcost > 0 && closedge[i].lowcost < maxv)
{
maxv = closedge[i].lowcost;
k = i;
}
return k;
/************************End************************/
}//Min
void MiniSpanTree_Prim(AMGraph G, VerTexType u){
//无向网G以邻接矩阵形式存储,从顶点u出发构造G的最小生成树T,输出T的各条边
/***************************Begin**********************/
int k = LocateVex(G,u);
for(int j = 0;j < G.vexnum;j ++ )
if(j != k) closedge[j] = {u,G.arcs[k][j]};
closedge[k].lowcost = 0;
for(int i = 1;i < G.vexnum;i ++ )
{
int k = Min(G);
char u0 = closedge[k].adjvex;
char v0 = G.vexs[k];
cout << "边" << ' ' << u0 << "--->" << v0 << endl;
closedge[k].lowcost = 0;
for(int j = 0;j < G.vexnum;j ++ )
if(G.arcs[k][j] < closedge[j].lowcost)
closedge[j] = {G.vexs[k],G.arcs[k][j]};
}
/**************************End************************/
}//MiniSpanTree_Prim
int main(){
AMGraph G;
CreateUDN(G);
MiniSpanTree_Prim(G , 'a');
return 0;
}//main
第2关:算法6.9 kruskal算法
//算法6.9 克鲁斯卡尔算法
#include <iostream>
using namespace std;
typedef char VerTexType; //假设顶点的数据类型为字符型
typedef int ArcType;
#define MVNum 100 //最大顶点数
#define MaxInt 32767 //表示极大值,即∞
//----------------图的邻接矩阵---------------------
typedef struct{
VerTexType vexs[MVNum]; //顶点表
ArcType arcs[MVNum][MVNum]; //邻接矩阵
int vexnum,arcnum; //图的当前点数和边数
}AMGraph;
//辅助数组Edges的定义
struct Edges{
VerTexType Head; //边的始点
VerTexType Tail; //边的终点
ArcType lowcost; //边上的权值
}Edge[(MVNum * (MVNum - 1)) / 2];
int Vexset[MVNum]; //辅助数组Vexset的定义
int LocateVex(AMGraph G , VerTexType v){
//确定点v在G中的位置
for(int i = 0; i < G.vexnum; ++i)
if(G.vexs[i] == v)
return i;
return -1;
}//LocateVex
void CreateUDN(AMGraph &G){
//采用邻接矩阵表示法,创建无向网G
int i , j , k;
cin >> G.vexnum >> G.arcnum; //输入总顶点数,总边数
for(i = 0; i < G.vexnum; ++i){
cin >> G.vexs[i]; //依次输入点的信息
}
for(i = 0; i < G.vexnum; ++i) //初始化邻接矩阵,边的权值均置为极大值MaxInt
for(j = 0; j < G.vexnum; ++j)
G.arcs[i][j] = MaxInt;
for(k = 0; k < G.arcnum;++k){ //构造邻接矩阵
VerTexType v1 , v2;
ArcType w;
cin >> v1 >> v2 >> w; //输入一条边依附的顶点及权值
i = LocateVex(G, v1); j = LocateVex(G, v2); //确定v1和v2在G中的位置,即顶点数组的下标
G.arcs[i][j] = w; //边<v1, v2>的权值置为w
G.arcs[j][i] = G.arcs[i][j]; //置<v1, v2>的对称边<v2, v1>的权值为w
Edge[k].lowcost = w;
Edge[k].Head = v1;
Edge[k].Tail = v2;
}//for
}//CreateUDN
//----------冒泡排序-------------------
void Sort(AMGraph G){
int m = G.arcnum - 2;
int flag = 1;
while((m > 0) && flag == 1){
flag = 0;
for(int j = 0 ; j <= m ; j++){
if(Edge[j].lowcost > Edge[j+ 1].lowcost){
flag = 1;
VerTexType temp_Head = Edge[j].Head;
Edge[j].Head = Edge[j+ 1].Head;
Edge[j + 1].Head = temp_Head;
VerTexType temp_Tail = Edge[j].Tail;
Edge[j].Tail = Edge[j+ 1].Tail;
Edge[j + 1].Tail = temp_Tail;
ArcType temp_lowcost = Edge[j].lowcost;
Edge[j].lowcost = Edge[j+ 1].lowcost;
Edge[j + 1].lowcost = temp_lowcost;
}//if
}//for
--m;
}//while
}//Sort
void MiniSpanTree_Kruskal(AMGraph G){
//无向网G以邻接矩阵形式存储,构造G的最小生成树T,输出T的各条边
/*************************Begin******************/
Sort(G);
for(int i = 0;i < G.vexnum;i ++ )
Vexset[i] = i;
for(int i = 0;i < G.arcnum;i ++ )
{
int v1 = LocateVex(G,Edge[i].Head);
int v2 = LocateVex(G,Edge[i].Tail);
int vs1 = Vexset[v1],vs2 = Vexset[v2];
if(vs1 != vs2)
{
cout << Edge[i].Head << "-->" << Edge[i].Tail << endl;
for(int j = 0;j < G.vexnum;j ++ )
if(Vexset[j] == vs2) Vexset[j] = vs1;
}
}
/*************************End*******************/
}//MiniSpanTree_Kruskal
int main(){
AMGraph G;
CreateUDN(G);
MiniSpanTree_Kruskal(G);
return 0;
}///main