最小生成树
存储结构: 数组(每一个元素存一条边的两个点以及权值)关键是找到符合条件的边存入数组。
找的方法:
贪心,先找最小的权值的边。
用并查集,看两个顶点是否有加入。
贪心的方法
先找最小的权值的边,再加上
#include"Graph.h"
#include"UFsets.h"
#include"Queue.h"
#include <iostream>
const double maxValue = 99999999.0; //机器可表示的、问题中不可能出现的大数
const int DefaultSize2 = 50;
//最小生成树边结点的类声明
template <typename T, typename E>
struct MSTEdgeNode {//T为顶点类型,其实在生成树中未用
int tail, head; //两顶点位置
E key; //边上的权值,为结点关键码
MSTEdgeNode() { //构造函数
tail = -1;
head = -1;
key = 0;
}
/* MSTEdgeNode<T,E>& operator = (const MSTEdgeNode<T,E> &x){//可以用默认
tail=x.tail;
head=x.head;
key=x.key;
return *this;
}*/
friend bool operator < (MSTEdgeNode<T, E>& n1, MSTEdgeNode<T, E>& n2);//类模板的友元函数必须是函数模板
friend bool operator > (MSTEdgeNode<T, E>& n1, MSTEdgeNode<T, E>& n2);//所以必须在这里声明,在类外定义
friend bool operator == (MSTEdgeNode<T, E>& n1, MSTEdgeNode<T, E>& n2);
friend bool operator <= (MSTEdgeNode<T, E>& n1, MSTEdgeNode<T, E>& n2);
};
template <typename T, typename E> bool operator < (MSTEdgeNode<T, E>& n1, MSTEdgeNode<T, E>& n2) {//只有在类外才能定义为函数模板
return n1.key < n2.key;
}
template <typename T, typename E> bool operator > (MSTEdgeNode<T, E>& n1, MSTEdgeNode<T, E>& n2) {
return n1.key > n2.key;
}
template <typename T, typename E> bool operator == (MSTEdgeNode<T, E>& n1, MSTEdgeNode<T, E>& n2) {
return n1.key == n2.key;
}
template <typename T, typename E> bool operator <= (MSTEdgeNode<T, E>& n1, MSTEdgeNode<T, E>& n2) {
return n1.key <= n2.key;
}
//最小生成树的类定义
template <typename T, typename E>
class MinSpanTree {
protected:
MSTEdgeNode<T, E>* edgevalue; //用边值数组表示树
int maxSize, n; //数组的最大元素个数和当前个数
public:
MinSpanTree(int sz = DefaultSize2 /*- 1*/) {
maxSize = sz;
n = 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(); //自定义函数,顺序输出所有边
void printMST(Graphmtx<T, E>& G);
};
template<class T, class E>
bool MinSpanTree<T, E>::Insert(MSTEdgeNode<T, E>& item) {
if (n == maxSize) {
return false;
}
edgevalue[n] = item;
n++;
return true;
}
template<class T, class E>
void MinSpanTree<T, E>::output() {
for (int i = 1; i <= n; i++) {
cout << "Edge " << i << " : " << "head = " << edgevalue[i - 1].head << " ; tail = " << edgevalue[i - 1].tail << " ; key = " << 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<MSTEdgeNode<T, E>> H(n); //最小堆存边集及权重信息
UnionFindSets 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.Union(u, v); //集合合并,连通
Insert(ed); //插入到最小生成树中
//cout<<ed.tail<<ed.head<<ed.key;
count++;
}
}
if (count < n)
{
cout << "不连通,无法生成最小生成树" << endl;
return false;
}
return true;
}
// 打印最小生成树
template <class T, class E>
void MinSpanTree<T, E>::printMST(Graphmtx<T, E>& 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;
}
}
执行结果 :
加边算法(Kruscal算法)
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;
F.output();
return true;
}