最小生成树(Prim,Kruskal)

Prime算法 （邻接矩阵存储图）：

初始时，任选一个顶点v，加入到节点集合V={v}
然后在与v相连的所有边中找出权值w最小的边，其节点为index1,此时 V={v,index1}
然后对v和index1这两个节点，找到与这两个节点相连的所以边中的最小边，其节点为index2,此时V = {v,index1,index2}
以此类推。

//dis[i]：表示集合V中的所有节点index 到 节点i的所有边里面的最小边的权值w
//closest[i]：存放最小边的起始点index
int closest[N], dis[N];
bool vis[N];
int g[N][N] = { {INF,1,3,4},
				{1,INF,2,INF},
				{3,2,INF,5},
				{4,INF,5,INF} 
			  };
void Prim(int v)
{
	//初始化
	int index = v;
	vis[v] = true;
	for (int i = 0; i < N; i++)
	{
		dis[i] = g[v][i];
		closest[i] = v;			//存放 节点i的对应节点v
	}

	for (int i = 1; i < N; i++)		//找n-1个节点
	{
		int min = INF;
		//遍历外边，找出最小的一条边和节点
		for (int j = 0; j < N; j++)
		{
			if (!vis[j] && dis[j] < min)
			{
				index = j;
				min = dis[j];
			}
		}
		//标记已加入集合V
		vis[index] = true;
		printf("边(%d，%d)的权值：%d\n", closest[index],index, min);
		//找到新的一个节点后，对dis数组进行更新
		for (int j = 0; j < N; j++)
		{
			if (!vis[j] && dis[j] > g[index][j])
			{
				dis[j] = g[index][j];
				closest[j] = index;
			}
		}
	}
}

Kruskal算法（邻接矩阵存储图）

思想：Kruskal算法是选边，并且不能构成环
思路：首先对所有的边从小到大排序，然后从最小的一条边选起，判断是否构成环，若不构成，则选上，否则丢弃。
方法：并查集

const int N = 4; 	//N：表示节点数
int g[N][N] = { {INF,1,3,4},
				{1,INF,2,INF},
				{3,2,INF,5},
				{4,INF,5,INF} 
			  };
struct Edge
{
	int from, to, w;
	bool operator<(const Edge b)
	{
		return w < b.w;
	}
}e[N*N];
int  p[N];
int cnt = 0;
void init()
{
	for(int i=0;i<N;i++)
		for (int j = 0; j < N; j++)
		{
			if (g[i][j] != INF)
			{
				e[cnt].from = i;
				e[cnt].to = j;
				e[cnt].w = g[i][j];
				cnt++;
			}
		}
	for (int i = 0; i < N; i++)
		p[i] = i;
}
int find(int x)
{
	while (x != p[x])
		x = p[x];
	return p[x];
}
void Union(int x, int y)
{
	p[find(x)] = find(y);
}
void Kruskal()
{
	init();
	sort(e, e + cnt);
	int count = 0;
	for (int i = 0; i < cnt; i++)
	{
		if (find(e[i].from) == find(e[i].to))
			continue;
		printf("边(%d，%d)的权值：%d\n",e[i].from,e[i].to,e[i].w);
		Union(e[i].from, e[i].to);
		count++;
		//选出N-1条边退出
		if (count == N - 1)
			break;
	}

}

总体代码：（邻接矩阵存储图）

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int INF = 10000;
const int N = 4;
int g[N][N] = { {INF,1,3,4},
				{1,INF,2,INF},
				{3,2,INF,5},
				{4,INF,5,INF} 
			  };

//dis[i]：表示集合V中的所有节点index 到 节点i的所有边里面的最小边的权值w
//closest[i]：存放最小边的起始点index
int closest[N], dis[N];
bool vis[N];
void Prim(int v)
{
	//初始化
	int index = v;
	vis[v] = true;
	for (int i = 0; i < N; i++)
	{
		dis[i] = g[v][i];
		closest[i] = v;			//存放 节点i的对应节点v
	}

	for (int i = 1; i < N; i++)		//找n-1个节点
	{
		int min = INF;
		//遍历外边，找出最小的一条边和节点
		for (int j = 0; j < N; j++)
		{
			if (!vis[j] && dis[j] < min)
			{
				index = j;
				min = dis[j];
			}
		}
		vis[index] = true;
		printf("边(%d，%d)的权值：%d\n", closest[index],index, min);
		//找到新的一个节点后，对dis数组进行更新
		for (int j = 0; j < N; j++)
		{
			if (!vis[j] && dis[j] > g[index][j])
			{
				dis[j] = g[index][j];
				closest[j] = index;
			}
		}
	}
}
struct Edge
{
	int from, to, w;
	bool operator<(const Edge b)
	{
		return w < b.w;
	}
}e[N*N];
int  p[N];
int cnt = 0;
void init()
{
	for(int i=0;i<N;i++)
		for (int j = 0; j < N; j++)
		{
			if (g[i][j] != INF)
			{
				e[cnt].from = i;
				e[cnt].to = j;
				e[cnt].w = g[i][j];
				cnt++;
			}
		}
	for (int i = 0; i < N; i++)
		p[i] = i;
}
int find(int x)
{
	while (x != p[x])
		x = p[x];
	return p[x];
}
void Union(int x, int y)
{
	p[find(x)] = find(y);
}
void Kruskal()
{
	init();
	sort(e, e + cnt);
	int count = 0;
	for (int i = 0; i < cnt; i++)
	{
		if (find(e[i].from) == find(e[i].to))
			continue;
		printf("边(%d，%d)的权值：%d\n",e[i].from,e[i].to,e[i].w);
		Union(e[i].from, e[i].to);
		count++;
		//选出N-1条边退出
		if (count == N - 1)
			break;
	}

}
int main()
{
	cout << "Prim算法求出的最小生成树："<<endl;
	Prim(0);
	cout << endl << "Kruskal算法求出的最小生成树："<<endl;
	Kruskal();
	return 0;
}