prime算法---普林姆算法---12月16日

prime算法

1. 从端点入手
   每一次选一个端点放入生成树中，（保证没有回路，即该点之前没有加入到生成树中）

2. 若把点加入到生成树中，则需要标记该邻接矩阵的对角线为1.

3. 如果所有的对角线都为1， 则生成完毕。这里可以用一个计数器来记录。

1.找所有与u邻接的点，存入权值到最小堆。

2.选一个v点与u点连接最小

3.直到所有点被遍历过

minspantree.h

#include"Graphms.h"
#include"UFsets.h"
#include"Queue.h"
#include <iostream>
const double maxValue = 99999.0;  	//机器可表示的、问题中不可能出现的大数
const int DefaultSize2 = 50;

//最小生成树的类定义(用数组存)
template <typename T, typename E>
class MinSpanTree {
protected:
	MSTEdgeNode<T, E>* edgevalue;			//用边值数组表示树
	int maxSize, currentSize;							//数组的最大元素个数和当前个数
public:
	MinSpanTree(int sz = DefaultSize2 ) {
		maxSize = sz;
		currentSize = 0;
		edgevalue = new MSTEdgeNode<T, E>[sz];
		//assert(edgevalue);
	}
	bool Kruscal(Graphmtx<T, E>& G); // Kruscal算法
	bool Insert(MSTEdgeNode<T, E>& item);	//将边item插入到树中，若树中节点已满，则返回false;
	void output(Graphmtx<T, E>& G);							//自定义函数，顺序输出所有边
	void printMST(Graphmtx<T, E>& G,int n);
	void Prim(Graphmtx<T, E>& G,const T u0, MinSpanTree<T, E>& MST);
};
template<class T, class E>
bool MinSpanTree<T, E>::Insert(MSTEdgeNode<T, E>& item) {
	if (currentSize == maxSize) {
		return false;
	}
	edgevalue[currentSize] = item;
	currentSize++;
	return true;
}

template<class T, class E>
void MinSpanTree<T, E>::output(Graphmtx<T, E>& G) {
	for (int i = 1; i <= currentSize; i++) {
		cout << "Edge " << i << " : " << "head = " << edgevalue[i - 1].head << " ; tail = " << edgevalue[i - 1].tail << " ; key = " << edgevalue[i - 1].key << endl;
		cout << "  点  " << G.getVertical(edgevalue[i - 1].head) << " 到   点" << G.getVertical(edgevalue[i - 1].tail) << " 权重是 " << edgevalue[i - 1].key << endl;
	}
}

template<class T, class E>
bool MinSpanTree<T, E>::Kruscal(Graphmtx<T, E>& G)
{
	MSTEdgeNode<T, E> ed;                    // 边结点辅助单元
	int u=0, v=0, count=0;
	int n = G.NumberofVertices();            // 图的顶点数
	E weight;               // 权值
	MinHeap<T,MSTEdgeNode<T, E>> H(n);       //最小堆存边集及权重信息
	UFSets F(n);     //并查集
	//把图的已知数据输入到最小堆中，插入之后就容易找到最小的数据
	for (u = 0; u < n; u++)
	{
		for (v = u + 1; v < n; v++)  //找该顶点的下一个与之有边的顶点
		{
			weight = G.getWeight(v,u);  //获得权重
			if (weight > 0 && weight < G.maxWeightG)
			{
				ed.head = u;
				ed.tail = v;
				ed.key = weight;
				H.Insert(ed);//插入最小堆中
			}
		}
	}
	count = 1;
	while (count < n && !H.IsEmpty())
	{
		H.RemoveMin(ed);   //找出最小的边
		u = F.Find(ed.tail);//在找的第一遍，是父节点就是自己，就返回自己数组下标。
		v = F.Find(ed.head);
		if (u != v) //当两个根不同时，进行合并。
		{
			F.SimpleUnion(u, v);  //集合合并，连通,连n-1次
			Insert(ed);  //插入到最小生成树中
		    cout<<" 点"<<G.getVertical(ed.tail)<<"到  点"<< G.getVertical(ed.head)<< " 权重是 "<<ed.key<<endl;
			count++;
		}
	}
	if (count < n)
	{
		cout << "不连通，无法生成最小生成树" << endl;
		return false;
	}

	cout << "输出最小生成树" << endl;
	output(G);

	return true;
}

//非成员函数
//prime算法
//u0表示起始点（例如‘A’）
template <class T, class E>
void MinSpanTree<T, E>::Prim(Graphmtx<T, E>& G, const T u0, MinSpanTree<T, E>& MST)
{
	MSTEdgeNode<T, E> ed;
	int i = 0, v = 0, count = 0;
	int n = G.NumberofVertices();          //顶点的数量
	int m = G.NumberofEdges();            //边的数量
	int u = G.getVertexPos(u0);           //取顶点对应的下标值。
	MinHeap<E, MSTEdgeNode<T, E>> H(m); //存边的最小堆
	G.putEdge(u);  //起点标记
	count = 1;
	do
	{
		v = G.getFirstNeighbor(u);   //找到与u 最近的邻接点
		//找所有与u邻接的点，存入权值到最小堆。
		while (v != -1)
		{
			if (G.outEdge(v)==0)
			{
				ed.tail = u; //起点
				ed.head = v;  //终点
				ed.key = G.getWeight(u, v);
				H.Insert(ed);
			}
			v = G.getNextNeighbor(u, v);  //把v传入的原因是需要找在v 之后的邻接点，之前的已经找过了
		}

		//选一个v点与u点连接最小
		while (H.IsEmpty() == false && count < n)
		{
			H.RemoveMin(ed);
			if (G.outEdge(ed.head) == 0)
			{
				MST.Insert(ed);
				u = ed.head;  //用新的头作为起点，找其他与他最近的点
				G.putEdge(ed.head);
				count++;
				break;  //这里找到一个就可以了，重新用新的u 找下一个
			}
		}
	} while (count < n);

	cout << "输出最小生成树" << endl;
	MST.printMST(G,n);
	
}


// 打印最小生成树
template <class T, class E>
void MinSpanTree<T, E>::printMST(Graphmtx<T, E>& G,int n) {
	int tail, head; // 顶点所在位置
	T e1, e2; // 两顶点
	E weight; //  权值
	currentSize = n-1;
	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;
	}
}