C++实现prim与kruskal算法

1. prim是根据访问过的结点来更新当前可以加入的最小边
2. kruskal是把所有边排序,然后一条条边加入,需要防止形成环

• 本程序使用接邻矩阵保存图,测试用例如下图:

#pragma once
#include <iostream>
#include <iomanip>
#include <map>
using namespace std;

template<class T>
class MatriGraphx
{
public:
	MatriGraphx(size_t capacity = 20);
	~MatriGraphx();

	class Vertex//顶点
	{
	public:
		Vertex(T v) : bVisited(0) { val = v; }
		friend class MatriGraphx<T>;
	private:
		T val;
		bool bVisited;
	};
public:
	void addVertex(T);//增加顶点
	void addEdge(int start, int end, int weight = 1);//增加连线，增加边
	void printMatrix();//打印邻接矩阵

	void prim();
	void Kruskal();
private:
	size_t m_size;  //顶点个数
	size_t m_capacity;   //最多可容纳顶点数

	Vertex** m_vArray; //顶点列表
	int** m_pMatrix; //邻接矩阵
};

template<class T>
inline MatriGraphx<T>::MatriGraphx(size_t c)
	:m_size(0),m_capacity(c)
{
	m_vArray = new Vertex* [c];
	m_pMatrix = new int* [c];

	for (size_t i = 0; i < c; i++)
	{
		m_pMatrix[i] = new int[c];
		//memset(m_pMatrix[i], 0, c * sizeof(int)); //初始化为0
	}

	//初始化矩阵,初始化为INT_MAX
	for (size_t i = 0; i < c; i++)
	{
		for (size_t j = 0; j < c; j++)
		{
			m_pMatrix[i][j] = INT_MAX;
		}
	}
}

template<class T>
inline MatriGraphx<T>::~MatriGraphx()
{
	delete[] m_vArray;
	delete[] m_pMatrix;
}

template<class T>
inline void MatriGraphx<T>::addVertex(T item)
{
	if (m_size == m_capacity)
		throw "超出容量";
	m_vArray[m_size++] = new Vertex(item);
}

template<class T>
inline void MatriGraphx<T>::addEdge(int start, int end, int weight)
{
	m_pMatrix[start][end] = m_pMatrix[end][start] = weight;
}

template<class T>
inline void MatriGraphx<T>::printMatrix()
{
	std::cout << "顶点个数为 " << m_size << " 个:" << std::endl;
	for (size_t i = 0; i < m_size; i++)
	{
		cout << setw(3) << m_vArray[i]->val << " ";
	}
	cout << endl << endl;

	for (size_t i = 0; i < m_size; i++)
	{
		for (size_t j = 0; j < m_size; j++)
		{
			if (m_pMatrix[i][j] < INT_MAX)
			{
				cout << setw(3) << m_pMatrix[i][j] << " ";
			}
			else
				cout << setw(3) << '-' << " ";
		}
		cout << endl;
	}
}

template<class T>
inline void MatriGraphx<T>::prim()
{
	int* closest = new int[m_size];  //最邻近数组
	int* parent = new int[m_size]; //保存父结点


	//初始化数组
	for (int i = 0; i < m_size; i++)
	{
		closest[i] = m_pMatrix[0][i];
		parent[i] = 0;
	}

	//开始结点
	std::cout << "普里姆算法开始结点: " << m_vArray[0]->val << std::endl;
	closest[0] = 0;  

	int min;
	int v;  //保存最小结点下标

	//构造最小生成树,遍历所有结点
	for (int i = 1; i < m_size; i++)
	{
		min = INT_MAX;

		//遍历最邻近数组,找出最小顶点
		for (int j = 1; j < m_size; j++)
		{
			if (closest[j] != 0 && min > closest[j])
			{
				v = j;
				min = closest[j];
			}
		}
		std::cout << m_vArray[parent[v]]->val << "->" << m_vArray[v]->val <<
			" weight: " << m_pMatrix[parent[v]][v]<< std::endl;
		closest[v] = 0; //已经访问置零,避免重复访问

		//更新最邻近数组
		for (int j = 1; j < m_size; j++)
		{
			if (closest[j] != 0 && m_pMatrix[v][j] < closest[j])
			{
				parent[j] = v;
				closest[j] = m_pMatrix[v][j];
			}
		}
	}

	delete[] closest;
	delete[] parent;
}

template<class T>
inline void MatriGraphx<T>::Kruskal()
{
	int* parent = new int[m_size]; //保存结点的连通分量,即用于查找有无环

	struct Edge
	{
		int begin;
		int end;
		int weight;
	};


	Edge* edge = new Edge[m_size*m_size];  //保存 边 边 权值
	int n = 0;   //保存边数

	//将边加入
	for (size_t i = 0; i < m_size; i++)
	{
		for (size_t j = i; j < m_size; j++)
		{
			if (m_pMatrix[i][j] < INT_MAX)
			{
				edge[n].begin = i;
				edge[n].end = j;
				edge[n].weight = m_pMatrix[i][j];
				n++;
			}
				
		}
	}
	//按照权值排序边
	qsort(edge, n, sizeof(Edge), 
		[] (const void* x1, const void* x2) -> int 
		{ 
			Edge* a = (Edge*)x1;
			Edge* b = (Edge*)x2;
			return a->weight > b->weight ? 1 : -1; 
		}
	);

	输出边集
	//for (size_t i = 0; i < n; i++)
	//{
	//	cout <<
	//		edge[i].begin << "->" <<
	//		edge[i].end << "  w: " <<
	//		edge[i].weight << endl;
	//}

	//查找是否连通函数,其原理是绕一圈查询是否形成环
	auto Find = [](const int* parent, int v) -> int
	{
		while (parent[v] > 0)
		{
			v = parent[v];
		}
		return v;
	};

	std::cout << "克鲁斯卡尔算法如下:" << std::endl;
	int begin, end;
	//遍历每条边
	for (size_t i = 0; i < n; i++)
	{
		begin = Find(parent, edge[i].begin);
		end = Find(parent, edge[i].end);

		//若相等则形成环
		if (begin != end)
		{
			parent[begin] = end;

			cout <<
				edge[i].begin << "->" <<
				edge[i].end << "  w: " <<
				edge[i].weight << endl;
		}
	}


	delete[] parent;
	delete[] edge;
}

---

测试用例

void main() {
	MatriGraphx<char> g(10);

	g.addVertex('0');//0
	g.addVertex('1');//1
	g.addVertex('2');//2
	g.addVertex('3');//3
	g.addVertex('4');//4
	g.addVertex('5');//5

	g.addEdge(0, 1, 6);
	g.addEdge(0, 2, 1);
	g.addEdge(0, 3, 5);
	g.addEdge(1, 2, 5);
	g.addEdge(1, 4, 3);
	g.addEdge(2, 3, 7);
	g.addEdge(2, 4, 5);
	g.addEdge(2, 5, 4);
	g.addEdge(3, 5, 2);
	g.addEdge(4, 5, 6);

	g.printMatrix();

	g.prim();

	g.Kruskal();

	std::cout << " " << std::endl;
}