一、思路:
和Kruscal类似,先从一个顶点u出发,找u的邻接顶点v,如果(u,v)权值最小且v顶点不在生成树顶点集合中(防止出现回路),则把边(u,v)存到最小生成树中;否则该顶点已经在生成树顶点集合中,舍弃该边,找权值次小的另一条边。然后,从顶点v出发,找下一条不会出现回路的边(v,w)。直到找到n-1条边。
1.假如从顶点A出发,找A的邻接顶点(不在生成树顶点集合中),且权值最小的边,则是(A,B,12),把该边加入到最小生成树中,顶点B加入到生成树顶点集合中;
2.从顶点B出发,找B的邻接顶点(不在生成树顶点集合中),且组成的权值最小的边,则是(B, F, 7),把该边加入到最小生成树中,顶点F加入到生成树顶点集合中;
3.如此重复,直到取了n-1条边,最后结果如下:
二、实现程序:
1.Graph.h:图的头文件
#ifndef Graph_h
#define Graph_h
#include
using namespace std;
const int DefaultVertices = 30;
template
struct Edge { // 边结点的定义
int dest; // 边的另一顶点位置
E cost; // 表上的权值
Edge *link; // 下一条边链指针
};
template
struct Vertex { // 顶点的定义
T data; // 顶点的名字
Edge *adj; // 边链表的头指针
};
template
class Graphlnk {
public:
const E maxWeight = 100000; // 代表无穷大的值(=∞)
Graphlnk(int sz=DefaultVertices); // 构造函数
~Graphlnk(); // 析构函数
void inputGraph(); // 建立邻接表表示的图
void outputGraph(); // 输出图中的所有顶点和边信息
T getValue(int i); // 取位置为i的顶点中的值
E getWeight(int v1, int v2); // 返回边(v1, v2)上的权值
bool insertVertex(const T& vertex); // 插入顶点
bool insertEdge(int v1, int v2, E weight); // 插入边
bool removeVertex(int v); // 删除顶点
bool removeEdge(int v1, int v2); // 删除边
int getFirstNeighbor(int v); // 取顶点v的第一个邻接顶点
int getNextNeighbor(int v,int w); // 取顶点v的邻接顶点w的下一邻接顶点
int getVertexPos(const T vertex); // 给出顶点vertex在图中的位置
int numberOfVertices(); // 当前顶点数
private:
int maxVertices; // 图中最大的顶点数
int numEdges; // 当前边数
int numVertices; // 当前顶点数
Vertex * nodeTable; // 顶点表(各边链表的头结点)
};
// 构造函数:建立一个空的邻接表
template
Graphlnk::Graphlnk(int sz) {
maxVertices = sz;
numVertices = 0;
numEdges = 0;
nodeTable = new Vertex[maxVertices]; // 创建顶点表数组
if(nodeTable == NULL) {
cerr << "存储空间分配错误!" << endl;
exit(1);
}
for(int i = 0; i < maxVertices; i++)
nodeTable[i].adj = NULL;
}
// 析构函数
template
Graphlnk::~Graphlnk() {
// 删除各边链表中的结点
for(int i = 0; i < numVertices; i++) {
Edge *p = nodeTable[i].adj; // 找到其对应链表的首结点
while(p != NULL) { // 不断地删除第一个结点
nodeTable[i].adj = p->link;
delete p;
p = nodeTable[i].adj;
}
}
delete []nodeTable; // 删除顶点表数组
}
// 建立邻接表表示的图
template
void Graphlnk::inputGraph() {
int n, m; // 存储顶点树和边数
int i, j, k;
T e1, e2; // 顶点
E weight; // 边的权值
cout << "请输入顶点数和边数:" << endl;
cin >> n >> m;
cout << "请输入各顶点:" << endl;
for(i = 0; i < n; i++) {
cin >> e1;
insertVertex(e1); // 插入顶点
}
cout << "请输入图的各边的信息:" << endl;
i = 0;
while(i < m) {
cin >> e1 >> e2 >> weight;
j = getVertexPos(e1);
k = getVertexPos(e2);
if(j == -1 || k == -1)
cout << "边两端点信息有误,请重新输入!" << endl;
else {
insertEdge(j, k, weight); // 插入边
i++;
}
} // while
}
// 输出图中的所有顶点和边信息
template
void Graphlnk::outputGraph() {
int n, m, i, j;
T e1, e2; // 顶点
E weight; // 权值
n = numVertices;
m = numEdges;
cout << "图中的顶点数为" << n << ",边数为" << m << endl;
for(i = 0; i < n; i++) {
for(j = i+1; j < n; j++) {
weight = getWeight(i, j); // 取边的权值
if(weight > 0 && weight < maxWeight) { // 有效
e1 = getValue(i); // 顶点
e2 = getValue(j);
cout << "(" << e1 << "," << e2 << "," << weight << ")" << endl;
}
} // 内循环for
} // 外循环for
}
// 取位置为i的顶点中的值
template
T Graphlnk::getValue(int i) {
if(i >= 0 && i < numVertices)
return nodeTable[i].data;
return NULL;
}
// 返回边(v1, v2)上的权值
template
E Graphlnk::getWeight(int v1, int v2) {
if(v1 != -1 && v2 != -1) {
Edge *p = nodeTable[v1].adj; // v1的第一条关联的边
while(p != NULL && p->dest != v2) { // 寻找邻接顶点v2
p = p->link;
}
if(p != NULL)
return p->cost;
}
return 0; // 边(v1, v2)不存在
}
// 插入顶点
template
bool Graphlnk::insertVertex(const T& vertex) {
if(numVertices == maxVertices) // 顶点表满,不能插入
return false;
nodeTable[numVertices].data = vertex; // 插入在表的最后
numVertices++;
return true;
}
// 插入边
template
bool Graphlnk::insertEdge(int v1, int v2, E weight) {
if(v1 >= 0 && v1 < numVertices && v2 >= 0 && v2 < numVertices) {
Edge *q, *p = nodeTable[v1].adj; // v1对应的边链表头指针
while(p != NULL && p->dest != v2) // 寻找邻接顶点v2
p = p->link;
if(p != NULL) // 已存在该边,不插入
return false;
p = new Edge; // 创建新结点
p->dest = v2;
p->cost = weight;
p->link = nodeTable[v1].adj; // 链入v1边链表
nodeTable[v1].adj = p;
q = new Edge;
q->dest = v1;
q->cost = weight;
q->link = nodeTable[v2].adj; // 链入v2边链表
nodeTable[v2].adj = q;
numEdges++;
return true;
}
return false;
}
// 删除顶点
template
bool Graphlnk::removeVertex(int v) {
if(numVertices == 1 || v < 0 || v > numVertices)
return false; // 表空或顶点号超出范围
Edge *p, *s, *t;
int k; // 存储邻接顶点
while(nodeTable[v].adj != NULL) {
p = nodeTable[v].adj;
k = p->dest; // 取邻接顶点k
s = nodeTable[k].adj; // 找对称存放的边结点
t = NULL;
while(s != NULL && s->dest != v) {
t = s;
s = s->link;
}
if(s != NULL) { // 删除对称存放的边结点
if(t == NULL) // 删除的是第一个邻接顶点
nodeTable[k].adj = s->link;
else
t->link = s->link;
delete s;
}
nodeTable[v].adj = p->link; // 清除顶点v的边链表结点
delete p;
numEdges--; // 与顶点v相关联的边数减1
} // while结束
numVertices--; // 图的顶点个数减1
nodeTable[v].data = nodeTable[numVertices].data; // 填补
p = nodeTable[v].adj = nodeTable[numVertices].adj;
// 要将填补的顶点对应的位置改写
while(p != NULL) {
s = nodeTable[p->dest].adj; // 对称边链表结点
while(s != NULL) {
if(s->dest == numVertices) { // 找到对称边
s->dest = v; // 修改指向v
break;
}
s = s->link;
}
p = p->link; // 指向下一个邻接顶点
}
return true;
}
// 删除边
template
bool Graphlnk::removeEdge(int v1, int v2) {
if(v1 != -1 && v2 != -1) {
Edge * p = nodeTable[v1].adj, *q = NULL, *s = p;
while(p != NULL && p->dest != v2) { // v1对应边链表中找被删除边
q = p;
p = p->link;
}
if(p != NULL) { // 找到被删除边结点
if(p == s) // 该结点是边链表的首结点
nodeTable[v1].adj = p->link;
else
q->link = p->link; // 不是,重新链接
delete p;
}
else // 没找到
return false;
// v2对应边链表中删除
p = nodeTable[v2].adj;
q = NULL;
s = p; // 保存首结点
while(p != NULL && p->dest != v1) { // 寻找边链表中要删除的结点
q = p;
p = p->link;
}
if(p == s) // 删除的该结点是边链表的首结点
nodeTable[v2].adj = p->link;
else
q->link = p->link; // 不是,重新链接
delete p;
return true;
}
return false; // 没有找到结点
}
// 取顶点v的第一个邻接顶点
template
int Graphlnk::getFirstNeighbor(int v) {
if(v != -1) {
Edge *p = nodeTable[v].adj; // 对应链表第一个边结点
if(p != NULL) // 存在,返回第一个邻接顶点
return p->dest;
}
return -1; // 第一个邻接顶点不存在
}
// 取顶点v的邻接顶点w的下一邻接顶点
template
int Graphlnk::getNextNeighbor(int v,int w) {
if(v != -1) {
Edge *p = nodeTable[v].adj; // 对应链表第一个边结点
while(p != NULL && p->dest != w) // 寻找邻接顶点w
p = p->link;
if(p != NULL && p->link != NULL)
return p->link->dest; // 返回下一个邻接顶点
}
return -1; // 下一个邻接顶点不存在
}
// 给出顶点vertex在图中的位置
template
int Graphlnk::getVertexPos(const T vertex) {
for(int i = 0; i < numVertices; i++)
if(nodeTable[i].data == vertex)
return i;
return -1;
}
// 当前顶点数
template
int Graphlnk::numberOfVertices() {
return numVertices;
}
#endif /* Graph_h */
2.prim.h
#ifndef prim_h
#define prim_h
#include
#include "Graph.h"
const int DefaultSize = 40; // 默认个数
template
struct MSTEdgeNode { // 最小生成树边结点的类声明
int head, tail; // 两顶点位置
E weight; // 边上权值
MSTEdgeNode():tail(-1), head(-1), weight(0){}; // 构造函数
};
template
bool operator<(const MSTEdgeNode &a,const MSTEdgeNode &b) {
if(a.weight > b.weight)
return true;
return false;
}
template
class MinSpanTree { // 最小生成树的类定义
public:
MinSpanTree(int sz = DefaultSize-1) { // 构造函数
maxSize = sz;
currentSize = 0;
edgeValue = new MSTEdgeNode[sz];
}
~MinSpanTree() { // 析构函数
delete []edgeValue; // 释放空间
}
bool Insert(MSTEdgeNode &item); // 插入
void Prim(Graphlnk &G, const T u0); // Prim算法
void printMST(Graphlnk &G); // 打印最小生成树
private:
int maxSize, currentSize; // 数组的最大元素个数和当前个数
MSTEdgeNode *edgeValue; // 用边值数组表示树
};
// 插入
template
bool MinSpanTree::Insert(MSTEdgeNode &item) {
if(currentSize == maxSize-1) {
cout << "已超出数组的存储范围!" << endl;
return false;
}
edgeValue[currentSize] = item;
currentSize++;
return true;
}
// Prim算法
template
void MinSpanTree::Prim(Graphlnk &G, const T u0) {
MSTEdgeNode ed; // 边点辅助单元
int i, u, v, count;
int n = G.numberOfVertices(); // 获取图的当前顶点数
u = G.getVertexPos(u0); // 求起始顶点号u
priority_queue> H; // 最小堆,关键码类型为E
bool visit[n]; // 最小生成树顶点集合
for(i = 0; i < n; i++) // 初始化为未访问过
visit[i] = false;
visit[u] = true; // u加入生成树,第一顶点
count = 1;
do { // n个顶点,要找n-1条边,组成最小生成树
// 1.先找到与v相关未被访问过的邻接顶点,然后把两者组成的边放到最小堆中
v = G.getFirstNeighbor(u); // 找u的第一个邻接顶点
while(v != -1) { // 重复检测u的所有邻接顶点
if(visit[v] == false) { // 该顶点未被访问过
ed.tail = u;
ed.head = v;
ed.weight = G.getWeight(u, v); // 获取(u,v)边的权值
H.push(ed);
}
v = G.getNextNeighbor(u, v); // 找顶点u的邻接顶点v的下一个邻接顶点
}
// 2.找当前顶点u与其他未被访问过的邻接顶点之间最小权值的边
while(H.empty() == false && count < n) {
ed = H.top(); // 从最小堆中退出具有最小权值的边ed
H.pop();
if(visit[ed.head] == false) { // 未被访问过
Insert(ed); // 插入到最小生成树中
u = ed.head;
visit[u] = true; // 标记为已访问,u加入生成树顶点集合
count++;
break;
}
}
}while(count < n);
}
// 打印最小生成树
template
void MinSpanTree::printMST(Graphlnk &G) {
int tail, head; // 顶点所在位置
T e1, e2; // 两顶点
E weight; // 权值
for(int i = 0; i < currentSize; i++) {
tail = edgeValue[i].tail; // 顶点所在位置
head = edgeValue[i].head;
e1 = G.getValue(tail); // 根据位置,取顶点对应的值
e2 = G.getValue(head);
weight = G.getWeight(tail, head); // 取权值
cout << "(" << e1 << "," << e2 << "," << weight << ")" << endl;
}
}
#endif /* prim_h */
3.main.cpp
/*
测试数据:
7 9
0 1 2 3 4 5 6
0 1 28
0 5 10
1 2 16
1 6 14
2 3 12
3 4 22
3 6 18
4 5 25
4 6 24
*/
#include "prim.h"
int main(int argc, const char * argv[]) {
Graphlnk G; // 声明图对象
MinSpanTree MST; //声明最小生成树对象
char u0;
// 创建图
G.inputGraph();
cout << "图的信息如下:" << endl;
G.outputGraph();
cout << "请输入第一个顶点u0:" << endl;
cin >> u0;
MST.Prim(G, u0); // 调用prim函数
cout << "根据Prim算法找出的最小生成树如下:" << endl;
// 打印最小生成树
MST.printMST(G);
return 0;
}
测试结果: