最小生成树之Prim算法实现

基本架构：先创建好一个邻接矩阵表示的图，然后按照prim算法思想找到最小生成树，注意将邻接矩阵表示的图在求最小生成树的时候转化为邻接表。

Prim 算法思想：

void Prim()

{

MST={V0};

while(1)

{

v=未收录顶点中dist最小的一个;

if(这样的v不存在)

break;

将v收录进MST中：dist[V]=0;

for(v的每个邻接点W)

{

if(dist[W]!=0)

if(E(v,w)<dist[W])

{

dist[W]=E(v,w);

parent[w]=v;

}

}

}

if(MST中的顶点个数小于|V|个)

cout<<"该图为非连通图！"<<endl;

}

代码实现：

// Prim最小生成树实现.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include<iostream>
#include<stdio.h>
#include<malloc.h>
#define MaxVertexNum 100
#define INFINITY 50
using namespace std;
typedef int Vertex;
typedef int WeightType;
typedef char DataType;
//边的定义,适合邻接矩阵和邻接表
typedef struct ENode *PtrToENode;
struct ENode
{
Vertex V1, V2;
WeightType Weight;
};
typedef PtrToENode Edge;
//邻接矩阵表示的图的建立
typedef struct MGNode *PtrToMGNode;
struct MGNode
{
int Nv;//顶点数
int Ne;//边数
WeightType G[MaxVertexNum][MaxVertexNum]; //邻接矩阵
DataType Data[MaxVertexNum];//顶点数组
};
typedef PtrToMGNode MGraph;

//邻接表表示的图的结构体定义
//邻接点的定义
typedef struct AdjVNode *PtrToAdjVNode;
struct AdjVNode
{
Vertex AdjV;    //邻接点下标
WeightType Weight; //边权重
PtrToAdjVNode Next; //指向下一个邻接点的指针
};
//点表头结点的定义
typedef struct Vnode
{
PtrToAdjVNode FirstEdge; //边表头指针
DataType Data;           //存顶点数据
}AdjList[MaxVertexNum];
//图结点的定义
typedef struct LGNode *PtrToLGNode;
struct LGNode
{
int vexnum;
int edgenum;
AdjList G;   //邻接表
};
typedef PtrToLGNode LGraph;
int visited[MaxVertexNum];//标志数组

//函数声明
LGraph CreateLGraph(int Vertexnum);
void InsertLEdge(LGraph Graph, Edge E);
LGraph BuildLGraph();
void DFSTravel(LGraph  Graph, Vertex V);
//函数定义
LGraph CreateLGraph(int Vertexnum)
{//初始化一个只有顶点，没有边的图
Vertex V;
LGraph Graph;
Graph = (LGraph)malloc(sizeof(struct LGNode));
Graph->vexnum = Vertexnum;
Graph->edgenum = 0;
for (V = 0; V<Graph->vexnum; V++)
{
Graph->G[V].FirstEdge = NULL;
}
return Graph;
}
void InsertLEdge(LGraph Graph, Edge E)
{
PtrToAdjVNode NewNode;
//插入边<v1,v2>
//为v2建立新的表结点
NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
NewNode->AdjV = E->V2;
NewNode->Weight = E->Weight;
NewNode->Next = Graph->G[E->V1].FirstEdge;
Graph->G[E->V1].FirstEdge = NewNode;
//若是无向图，还需插入边<v2,v1>
//为v1建立新的结点
NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
NewNode->AdjV = E->V1;
NewNode->Weight = E->Weight;
NewNode->Next = Graph->G[E->V2].FirstEdge;
Graph->G[E->V2].FirstEdge = NewNode;
}
LGraph BuildLGraph()
{

LGraph Graph;
Edge E;
Vertex V;
int vexnum, i;
std::cout << "请输入顶点个数：";
cin >> vexnum;
Graph = CreateLGraph(vexnum);
std::cout << "请输入边的个数：";
cin >> Graph->edgenum;
if (Graph->edgenum != 0)
{
E = (Edge)malloc(sizeof(struct ENode));
for (i = 0; i<Graph->edgenum; i++)
{
cin >> E->V1 >> E->V2 >> E->Weight;
InsertLEdge(Graph, E);
}
}
//如果顶点有数据的话，读入数据
for (V = 0; V<Graph->vexnum; V++)
cin >> Graph->G[V].Data;
std::cout << "创建好的邻接表输出如下所示：" << endl;
for (V = 0; V<Graph->vexnum; V++)
{
PtrToAdjVNode W;
std::cout << Graph->G[V].Data << "的邻接点：";
for (W = Graph->G[V].FirstEdge; W; W = W->Next)
{
std::cout << W->AdjV << "," << Graph->G[W->AdjV].Data << "," << W->Weight << "  ";
}
std::cout << endl;
}
return Graph;
}

//深度优先遍历图
/*void DFSTravel(LGraph  Graph, Vertex V)
{
PtrToAdjVNode W;
cout << Graph->G[V].Data;
visited[V] = 1;
for (W = Graph->G[V].FirstEdge; W; W = W->Next)
if (!visited[W->AdjV])
DFSTravel(Graph, W->AdjV);
}*/
//邻接矩阵表示的图的实现
MGraph CreateMGraph(int Vertexnum)
{//初始化一个有Vertexnum个顶点但没有变得图
Vertex V, W;
MGraph Graph;
Graph = (MGraph)malloc(sizeof(struct MGNode));
Graph->Nv = Vertexnum;
Graph->Ne = 0;
for (V = 0; V<Graph->Nv; V++)
{
for (W = 0; W<Graph->Nv; W++)
Graph->G[V][W] = INFINITY;
//如果是有权无向图，应该是
//Graph->G[V][W] =Graph->G[W][V] = INFINITY;
//如果是无权图有向图，可以初始化为0；
//Graph->G[V][W] = 0;
//如果是无权无向图，应该是
//Graph->G[V][W] =Graph->G[W][V] = 0;
}
return Graph;
}

void InsertMEdge(MGraph Graph, Edge E)
{//插入边
Graph->G[E->V1][E->V2] = E->Weight;
//若是无向图，则需要插入这条边
Graph->G[E->V2][E->V1] = E->Weight;
//若是无权有向图，
//Graph->G[E->V1][E->V2]=1;
//若是无权无向图，
///Graph->G[E->V2][E->V1] = 1;
}
MGraph BuildMGraph()
{
MGraph Graph;
Edge E;
Vertex V;
int i;
int Nv;
std::cout << "请输入顶点个数：";
cin >> Nv;
Graph = CreateMGraph(Nv);
std::cout << "请输入边的个数：";
cin >> Graph->Ne;
if (Graph->Ne != 0)
{
E = (Edge)malloc(sizeof(struct ENode));
for (i = 0; i<Graph->Ne; i++)
{
cin >> E->V1 >> E->V2 >> E->Weight;
//如果是无权图
//cin>>E->V1>>E->V2;
InsertMEdge(Graph, E);
}
}
for (V = 0; V<Graph->Nv; V++)
cin >> Graph->Data[V];
Vertex W;
std::cout << "创建好的邻接矩阵如下所示：" << endl;
for (V = 0; V<Graph->Nv; V++)
{
for (W = 0; W < Graph->Nv; W++)
std::cout << Graph->G[V][W] << "  ";
std::cout << endl;
}
return Graph;
}
Vertex FindMinDist(MGraph Graph, WeightType dist[])
{
Vertex  MinV, V;
WeightType  MinDist = INFINITY;
for (V = 0; V<Graph->Nv; V++)
{
if (dist[V] != 0 && dist[V]<MinDist)
{
MinDist = dist[V];
MinV = V;
}
}
if (MinDist<INFINITY)
return MinV;
else
return -1;
}
void Prim(MGraph Graph, LGraph MST)
{
WeightType dist[MaxVertexNum], TotalWeight;
Vertex parent[MaxVertexNum], V, W;
int VCount;
Edge E;
//初始化，默认初始化定点下标为0
for (V = 0; V<Graph->Nv; V++)
{
dist[V] = Graph->G[0][V];
parent[V] = 0;
}
TotalWeight = 0;
VCount = 0;
//创建包含所有顶点但没有边的图，用邻接表表示
MST = CreateLGraph(Graph->Nv);
E = (Edge)malloc(sizeof(struct ENode));
//将初始点0收录到MST
dist[0] = 0;
VCount++;
parent[0] = -1;
while (1)
{
V = FindMinDist(Graph, dist);
if (V == -1)
break;
//将V及其相应的边<parent[V],V>收录进MST
E->V1 = parent[V];
E->V2 = V;
E->Weight = dist[V];
InsertLEdge(MST, E);
TotalWeight += dist[V];
dist[V] = 0;
VCount++;

for (W = 0; W<Graph->Nv; W++)
{
if (dist[W] != 0 && Graph->G[V][W]<INFINITY)
//若W是v的邻接点，且没有被收录
{
if (Graph->G[V][W]<dist[W])
{
dist[W] = Graph->G[V][W];
parent[W] = V;
}
}
}
}
if (VCount<Graph->Nv)
{
TotalWeight = -1;
}
std::cout << "最小生成树的总权值：" << TotalWeight << endl;
std::cout << "输出创建好的最小生成树的邻接表表示：" << endl;
for (V = 0; V<MST->vexnum; V++)
{
PtrToAdjVNode W;
std::cout << V<< "的邻接点：";
for (W = MST->G[V].FirstEdge; W; W = W->Next)
{
std::cout << W->AdjV<< "," << W->Weight << "  ";
}
std::cout << endl;
}
}
int _tmain(int argc, _TCHAR* argv[])
{
MGraph  Graph;
LGraph  MST = NULL;
Graph = BuildMGraph();
Prim(Graph, MST);
return 0;
}