算法导论 19-2 采用二项堆的最小生成树算法

一、题目

二、分析

1.算法

先把每个顶点作为一个集合称为V，初始时每个Vi只有一个顶点i，随着算法的进行，会将一个集合合并，集合数量越来越少，而集合中的点越来越多。当只剩下一个集合时，算法结束。

每个顶点集合对应一个边的集合，称为E，所有以顶点i为顶点的边都放入Ei中。将Vj合并到Vi的同时，也会把Ej合并到Ei中。

任意选择一个顶点集合Vi，以及对应的Ei，从Ei中选择边权最小的边e，令e的两个端点分别为a,b（其中有一个等于i）。如果a和b属于同一个顶点集合，则不作处理。如果a和b属于不同的顶点集合，假设分别是Va和Vb，则认为e是最小生成树中的一个边，且把Vb合并到Va中，把Eb合并到Ea中。

2.结构

（1）T是一个边的集合，用于保存最小生成树的边。本文中没有保存这个结果，还是直接输出。

（2）V是顶点的集合，包括以下操作：

a.合并

b.判断两个点是否属于同一个集合

c.剩余集合的个数

d.选择一个集合

本文使用并查集，使用了 并查集中的模版，并有部分改动。

（3）E是边的集合，包括以下操作：

a.合并

b.向集合中插入一个元素

c.提取出集合中权值最小的元素

本文使用二项堆，使用了 算法导论-第19章-二项堆中的模板，并做了以下改动

a.在模板二项堆结点中卫星数据data没有被使用，本文中把边的信息作为卫星数据

b.边的权值作为二项堆结点的关键字

（4）G是无向图，本文使用邻接表的方式存储，每条边存两遍。这样写是为了让算法结果完整，事实上没有必要这个复杂，只存储每条边的起点、终点和边权就可以了。

三、代码

graph.h

#pragma once
#include   
#include   
#include "UnionFindSet.h"  
using namespace std;  
//边  
struct Edge  
{  
    int start;//起点  
    int end;//终点  
    int key;//长度  
	Edge *next;
	Edge(int s, int e, int k):start(s),end(e),key(k),next(NULL){}
}; 
//点
struct Vertex
{
	Edge *head;
	Vertex():head(NULL){}
};
//图
class Graph
{
public:
	int N;
	Vertex *V;

	Graph(int n);
	void Input();
	void Insert(int start, int end, int key);
};
Graph::Graph(int n):N(n)
{
	V = new Vertex[n+1];
}
void Graph::Input()
{
	int start, end, key;
	while(cin>>start && start)
	{
		cin>>end>>key;
		//因为是无向图，每条边要存两次
		Insert(start, end, key);
		Insert(end, start, key);
	}
}
void Graph::Insert(int start, int end, int key)
{
	Edge *e = new Edge(start, end, key);
	if(V[start].head)
	{
		e->next = V[start].head->next;
		V[start].head->next = e;
	}
	else
		V[start].head = e;
}

UnionFindSet.h

/* 
UnionFindSet.h 
并查集，非递归方法，含路径压缩，数组从0开始
合并时，前者合并入后者，不区分大小
*/ 
#pragma once
#include    
using namespace std;  
  
#define MAXN 15  
  
class UFS
{
public:
	int N;
	int father[MAXN+1];//集合根结点
	//addition
	int num;
public:
	UFS(int size = MAXN);
	void clear();
	int Find(int x);
	//a并入b中，不区分大小
	//value表示：如果a并入b中，a中r所有元素能获得的值
	void Union(int a, int b, int value = 0);
	//addition
	int Select(int start);
};
UFS::UFS(int size):N(size)
{
	//必须从0开始
	for(int i = 0; i <= N; i++)  
		father[i] = i;  
	num = size;
}
void UFS::clear()
{
	for(int i = 0; i <= N; i++)  
		father[i] = i;  
}
int UFS::Find(int x)
{
	int temp = x,sum = 0,ans;  
    while(temp != father[temp]) {  
       temp = father[temp];  
    }  
    ans = temp;  
    while(x != ans) {  
       temp = father[x];  
       father[x] = ans;  
       x = temp;  
    }  
    return ans;
}
void UFS::Union(int a, int b,int value)
{
	int x = Find(a);  
    int y = Find(b);
	if(x == y)
		return ;
	if(value >= 0)
	father[y] = x; 
	//addition
	num--;
}
int UFS::Select(int start)
{
	int i;
	for(i = start; i <= N; i++)
		if(father[i] == i)
			return i;
}

Binomial_Heap.h

#include 
#include "Graph.h"
using namespace std;

//二项堆结点结构
struct node
{
	int key;//关键字
	Edge data;//卫星数据
	node *p;//指向父结点的指针，父或左兄
	node *child;//指向左孩子的指针
	node *sibling;//指向右兄弟的指针
	int degree;//度
	//初始化
	node(Edge e, node *nil)
		:key(e.key),data(e),p(nil),child(nil),sibling(nil),degree(0){}
};	

//二项堆结构
class Binomial_Heap
{
public:
	node *head;
	node *nil;
	//构造函数
	Binomial_Heap(){nil = new node(Edge(-1,-1,-1), nil);}
	Binomial_Heap(node *NIL){nil = NIL;}
	//19.2
	void Make_Binomial_Heap();
	node* Binomial_Heap_Minimum();
	void Binomial_Link(node *y, node *z);
	node *Binomial_Heap_Merge(Binomial_Heap *H1, Binomial_Heap *H2);
	void Binomial_Heap_Union(Binomial_Heap *H2);
	void Binomial_Heap_Insert(node *x);
	node* Binomial_Heap_Extract_Min();
	void Binomial_Heap_Decrease_Key(node *x, int k);
	void Binomial_Heap_Delete(node *x);
};

//构造一个空的二项堆
void Binomial_Heap::Make_Binomial_Heap()
{
	//初始化对象
	head = nil;
}
//寻找最小关键字
node* Binomial_Heap::Binomial_Heap_Minimum()
{
	//最小关键字一定位于某个二项树的根结点上
	node *x = head, *y = nil;
	int min = 0x7fffffff;
	//遍历每个二项树的根结点
	while(x != nil)
	{
		//找出最小值
		if(x->key < min)
		{
			min = x->key;
			y = x;
		}
		x = x->sibling;
	}
	return y;
}	
//将以结点y为根的树与以结点z为根的树连接起来，使z成为y的父结点
void Binomial_Heap::Binomial_Link(node *y, node *z)
{
	//只是按照定义修改指针
	y->p = z;
	y->sibling = z->child;
	z->child = y;
	//增加度
	z->degree++;
}
//将H1和H2的根表合并成一个按度数的单调递增次序排列的链表
//不带头结点的单调链表的合并，返回合并后的头，不需要解释
node *Binomial_Heap::Binomial_Heap_Merge(Binomial_Heap *H1, Binomial_Heap *H2)
{
	node *l1 = H1->head, *l2 = H2->head, *ret = nil, *c = ret, *temp;
	while(l1 != nil && l2 != nil)
	{
		if(l1->degree <= l2->degree)
			temp = l1;
		else
			temp = l2;
		if(ret == nil)
		{
			ret = temp;
			c = ret;
		}
		else
		{
			c->sibling = temp;
			c = temp;
		}
		if(l1 == temp)l1 = l1->sibling;
		else l2 = l2->sibling;
	}
	if(l1 != nil)
	{
		if(ret == nil)
			ret = l1;
		else
			c->sibling = l1;
	}
	else
	{
		if(ret == nil)
			ret = l2;
		else
			c->sibling = l2;
	}
	delete H2;
	return ret;
}
//将两个二项堆合并
void Binomial_Heap::Binomial_Heap_Union(Binomial_Heap *H2)
{
	//H是合并结点，用于输出
	Binomial_Heap *H = new Binomial_Heap(nil);
	H->Make_Binomial_Heap();
	Binomial_Heap *H1 = this;
	//将H1和H2的根表合并成一个按度数的单调递增次序排列的链表，并放入H中
	H->head = Binomial_Heap_Merge(H1, H2);
	//free the objects H1 and H2 but not the lists they point to
	//如果H为空，直接返回
	if(H->head == nil)
		return;
	//将相等度数的根连接起来，直到每个度数至多一个根时为止
	//x指向当前被检查的根，prev-x指向x的前面一个根，next-x指向x的后一个根
	node *x = H->head, *prev_x = nil, *next_x = x->sibling;
	//根据x和next-x的度数来确定是否把两个连接起来
	while(next_x != nil)
	{
		//情况1：度数不相等
		if(x->degree != next_x->degree || 
			//情况2：x为具有相同度数的三个根中的第一个
			(next_x->sibling != nil && next_x->sibling->degree == x->degree))
		{
			//将指针指向下一个位置
			prev_x = x;
			x = next_x;
		}
		//情况3：x->key较小，将next-x连接到x上，将next-x从根表中去掉
		else if(x->key <= next_x->key)
		{
			//去掉next-x
			x->sibling = next_x->sibling;
			//使next-x成为x的左孩子
			Binomial_Link(next_x, x);
		}
		//情况4：next-x->key关键字较小，x被连接到next-x上
		else
		{
			//将x从根表中去掉
			if(prev_x == nil)//x是根表中的第一个根
				H->head = next_x;
			else//x不是根表中的第一个根
				prev_x->sibling = next_x;
			//使x成为next-x的最左孩子
			Binomial_Link(x, next_x);
			//更新x以进入下一轮迭代
			x = next_x;
		}
		next_x = x->sibling;
	}
	head = H->head;
}
//将结点x插入到二项堆H中
void Binomial_Heap::Binomial_Heap_Insert(node *x)
{
	//构造一个临时的二项堆HH，只包含一个结点x
	Binomial_Heap *HH = new Binomial_Heap;
	HH->Make_Binomial_Heap();
	x->p = nil;
	x->child = nil;
	x->sibling = nil;
	x->degree = 0;
	HH->head = x;
	//将H与HH合并，同时释放HH
	Binomial_Heap_Union(HH);
}
//抽取具有最小关键字的结点
node* Binomial_Heap::Binomial_Heap_Extract_Min()
{
	//find the root x with the minimum key in the root list of H, and remove x from the root list of H
	//最小关键字一定位于某个二项树的根结点上
	node *x = head, *y = nil, *ret;
	int min;
	if(x == nil)
	{
		//cout<<"empty"<key;
	//遍历每个二项树的根结点，为了删除这个结点，还需要知道x的前一个根结点
	while(x->sibling != nil)
	{
		//找出最小值
		if(x->sibling->key < min)
		{
			min = x->sibling->key;
			y = x;
		}
		x = x->sibling;
	}
	ret = x;
	//设待删除结点是二项树T的根，那么删除这个结点后，T变成了一个二项堆
	Binomial_Heap *HH = new Binomial_Heap;
	HH->Make_Binomial_Heap();
	//删除结点分为两个情况，结点是二项堆中的第一个树
	if(y == nil)
	{
		x = head;
		HH->head = x->child;	
		head = x->sibling;
	}
	//结点不是二项堆中的第一个树
	else
	{
		x = y->sibling;
		y->sibling = x->sibling;
		HH->head = x->child;
	}
	//原二项堆H删除二项树T后成为新二项堆H，二项树T删除根结点后变成新二项堆HH
	//将H和HH合并
	Binomial_Heap_Union(HH);
	return x;
}
//将二项堆H中的某一结点x的关键字减小为一个新值k
void Binomial_Heap::Binomial_Heap_Decrease_Key(node *x, int k)
{
	//引发错误
	if(k > x->key)
	{
		cout<<"new key is greater than current key"<key = k;
	node *y = x, *z = y->p;
	while(z != nil && y->key < z->key)
	{
		swap(y->key, z->key);
		swap(y->data, z->data);
		y = z;
		z = y->p;
	}
}
//删除一个关键字
void Binomial_Heap::Binomial_Heap_Delete(node *x)
{
	//将值变为最小，升到堆顶
	Binomial_Heap_Decrease_Key(x, -0x7fffffff);
	//删除堆顶元素
	Binomial_Heap_Extract_Min();
}

main.cpp

#include 
using namespace std;

#include "Graph.h"
#include "UnionFindSet.h"
#include "Binomial_Heap.h"

#define N 15

int n;
void Mst(Graph *G)
{
	int i;
	Vertex *v;
	Edge *e;
	//L3，为每个点保持一个划分
	UFS V(n);
	//L4，每个点对应一个与点关联的边的集合
	Binomial_Heap *E[N];
	for(i = 1; i <= n; i++)
	{
		//生成集合
		if(i == 1)
			E[i] = new Binomial_Heap();
		else
			E[i] = new Binomial_Heap(E[1]->nil);
		//把边加入到集合中，边信息是结点的附加信息，边权值是结点的关键字
		E[i]->Make_Binomial_Heap();
		v = &G->V[i];
		e = v->head;
		while(e)
		{
			node *temp = new node(*e, E[i]->nil);
			E[i]->Binomial_Heap_Insert(temp);
			e = e->next;
		}
	}
	cout<<"answer"< 1)
	{
		//L6，选择其中一个划分
		id = V.Select(id);
		//L7，提取该划分对应的边集合中权值最小的边
		node *ret = E[id]->Binomial_Heap_Extract_Min();
		//如果该集合为空，重新选择一个划分
		if(ret == E[id]->nil)
		{
			id++;
			continue;
		}
		Edge minE = ret->data;
		//L8，该边的两个顶点是否属于同一个划分
		int a = V.Find(minE.start);
		int b = V.Find(minE.end);
		//L9，该边的两个顶点不属于同一个划分
		if(a != b)
		{
			//L10，这条边是所求结果
			cout<Binomial_Heap_Union(E[b]);
		}
	}
}
/*
9
1 2 4
1 8 8
2 8 11
8 9 7
9 3 2
2 3 8
7 8 1
9 7 6
3 4 7
3 6 4
6 7 2
4 6 14
4 5 9
5 6 10
0*/
int main()
{
	//输入点的个数，从1开始计数
	cin>>n;
	//生成无向图
	Graph *G = new Graph(n);
	G->Input();
	//求最短路径树，结果直接输出
	Mst(G);
	return 0;
}

四、测试结果