数据结构探险——图的最小生成树算法

@这篇文档是由C++代码实现的图然后进行最小生成树的实现

最小生成树算法分为普利姆算法和克鲁斯卡尔算法。普利姆算法是从给出的一个顶点开始，选出跟该顶点相连的所有的边中权值最小的边，然后将该边的另外一个顶点和该边加入到集合中去，然后递归寻找已遍历的所有顶点的最小的边，逐渐形成一个最小生成树。克鲁斯卡尔算法是首先将所有的边加入到一个集合中去，然后从这个集合中寻找权值最小的边并取出，并保证该边不与已经取出的边形成回路，这样最后得到一个最小生成树。

本文是以Visual Studio中新建的C++win32的控制台应用程序实现的，其中建立了头文件和源文件以及实现main()的demo文件，分别是Node.h和Node.cpp和Edge.h和Edge.cpp和Cmap.h和Cmap.cpp和demo.cpp文件。

其中edge.h文件定义了一个边所有的数据成员，包括两个顶点的序号和该边的权值。Node.h定义了结点的数据成员，包括储存数据的m_cData和该结点是否被访问过的布尔值，还有结点的构造函数。Cmap.h中定义了图元素所拥有的数据成员和成员函数。demo.h中以下图中的无向图为例，将图元素存入图中，并将图中的弧也存入一个数组中，相当于一个矩阵。

Node.h文件

#ifndef NODE_H
#define NODE_H

class Node
{
public:
	Node(char data=0);
	char m_cData;				//当前结点的数据值
	bool m_bIsVisited;			//当前结点是否被访问过
};

#endif

Node.cpp文件

#include "Node.h"

Node::Node(char data)
{
	m_cData = data;
	m_bIsVisited = false;
}

Edge.h文件

#ifndef EDGE_H
#define EDGR_H

class Edge
{
public:
	Edge(int nodeIndexA=0,int nodeIndexB=0,int weightValue=0);
	int m_iNodeIndexA;
	int m_iNodeIndexB;
	int m_iWeightValue;
	bool m_bSelected;
};


#endif

Edge.cpp文件

#include "Edge.h"

Edge::Edge(int nodeIndexA,int nodeIndexB,int weightValue)
{
	m_iNodeIndexA = nodeIndexA;
	m_iNodeIndexB = nodeIndexB;
	m_iWeightValue = weightValue;
	m_bSelected = false;
}

Cmap.h文件

#ifndef CMAP_H
#define CMAP_H
#include "Node.h"
#include "Edge.h"
#include <iostream>
#include <vector>
using namespace std;

class Cmap
{
public:
	Cmap(int capacity);
	~Cmap();
	bool addNode(Node *pNode);			//向图中加入顶点
	void resetNode();					//重置顶点
	bool setValueToMatrixForDirectedGraph(int row, int col, int val=1);		//为有向图设置邻接矩阵
	bool setValueToMatrixForUndirectedGraph(int row, int col, int val=1);	//为无向图设置邻接矩阵

	void printMatrix();		//打印邻接矩阵
	void depthFirstTraverse(int nodeIndex);			//深度优先遍历
	void breadthFirstTraverse(int nodeIndex);		//广度优先遍历
	void primTree(int nodeIndex);					//普利姆算法最小生成树
	void kruskalTree();								//克鲁斯卡尔算法最小生成树

private:
	bool getValueFromMatrix(int row,int col, int &val);		//从矩阵中获取权值
	void breadthFirstTraverseImpl(vector<int> preVec);		//广度优先遍历实现函数
	//void primTreeImpl(vector<int> preNodeVec,vector<int> preEdgeVec);
	int getMinEdge(vector<Edge> edgeVec);
	bool isInSet(vector<int> nodeSet, int target);							//判断顶点是否在点集合中
	void mergeNodeSet(vector<int> &nodeSetA, vector<int> nodeSetB);			//合并两个顶点集合



	int m_iCapacity;			//图中最多可以容纳的顶点数
	int m_iNodeCount;			//已经添加的顶点（结点）个数
	Node *m_pNodeArray;			//用来存放顶点数组
	int *m_pmatrix;				//用来存放邻接矩阵
	Edge *m_pEdge;				//最小生成树边的集合
};

#endif

Camp.cpp文件

#include "Cmap.h"
#include <iostream>
#include <vector>
using namespace std;


Cmap::Cmap(int capacity)
{
	m_iCapacity = capacity;
	m_iNodeCount = 0;													//已经添加顶点的个数
	m_pNodeArray = new Node[m_iCapacity];								//已经添加的顶点的数组集合
	m_pmatrix = new int[m_iCapacity*m_iCapacity];						//已经添加的顶点的邻接矩阵
	//memset(m_pmatrix,0,m_iCapacity*m_iCapacity*sizeof(int));			//memset(数组名，用于替换的字符，前n个字符)，该函数用于对较大的数组清零操作
	for (int i=0;i<m_iCapacity*m_iCapacity;i++)
	{
		m_pmatrix[i] = 0;
	}
	m_pEdge = new Edge[m_iCapacity-1];									//最小生成树边的集合
}

Cmap::~Cmap()
{
	delete []m_pEdge;
	delete []m_pNodeArray;
	delete []m_pmatrix;
}

/*向图中加入顶点*/
bool Cmap::addNode(Node *pNode)			
{
	if (pNode == NULL)
	{
		return false;
	}
	m_pNodeArray[m_iNodeCount].m_cData = pNode->m_cData;
	m_iNodeCount++;
	return true;
}

/*重置所有顶点是否访问过的属性为否*/
void Cmap::resetNode()
{
	for (int i=0;i<m_iNodeCount;i++)
	{
		m_pNodeArray[i].m_bIsVisited = false;
	}
}

/*为有向图设置邻接矩阵,弧的权值由val元素定，可以用0或者1表示他们之间是否连接，也可以使用其他数值给予一定的权值*/
/*只不过有向图中的相同两个结点之间的弧的权值不一定相等，所以要分开赋值*/
/*由于val的值是默认给出的，所以val的参数值可以省略*/
bool Cmap::setValueToMatrixForDirectedGraph(int row, int col, int val)		
{
	if (row <0 || row >= m_iCapacity)
	{
		return false;
	}
	if (col <0 || col >= m_iCapacity)
	{
		return false;
	}
	m_pmatrix[row*m_iCapacity +col] = val;
	return true;
}

/*为有向图设置邻接矩阵,弧的权值由val元素定，可以用0或者1表示他们之间是否连接，也可以使用其他数值给予一定的权值*/
/*而有向图中的相同两个结点之间的弧的权值是相等的，所以统一赋值即可*/
/*由于val的值是默认给出的，所以val的参数值可以省略*/
bool Cmap::setValueToMatrixForUndirectedGraph(int row, int col, int val)	
{
	if (row <0 || row >= m_iCapacity)
	{
		return false;
	}
	if (col <0 || col >= m_iCapacity)
	{
		return false;
	}
	m_pmatrix[row*m_iCapacity +col] = val;
	m_pmatrix[col *m_iCapacity + row] = val;
	return true;
}


/*邻接矩阵是存放在一个数组中的，所以打印的时候隔一定的时间要分行打印*/
void Cmap::printMatrix()		
{
	for (int i=0;i<m_iCapacity;i++)
	{
		for (int j=0;j<m_iCapacity;j++)
		{
			cout << m_pmatrix[i*m_iCapacity+j] << " ";
		}
		cout << endl;
	}
}

/*获取矩阵中的某条弧的权值，是通过在数组中的位置获得的*/
bool Cmap::getValueFromMatrix(int row,int col, int &val)
{
	if (row <0 || row >= m_iCapacity)
	{
		return false;
	}
	if (col <0 || col >= m_iCapacity)
	{
		return false;
	}
	val = m_pmatrix[row*m_iCapacity + col];
	return true;
}


/*深度优先遍历算法*/
void Cmap::depthFirstTraverse(int nodeIndex)
{
	int value = 0;
	cout << nodeIndex << ":" <<m_pNodeArray[nodeIndex].m_cData << " ";
	m_pNodeArray[nodeIndex].m_bIsVisited = true;
	for (int i=0;i<m_iCapacity;i++)
	{
		getValueFromMatrix(nodeIndex,i,value);
		if (value == 1)
		{
			if (m_pNodeArray[i].m_bIsVisited)
			{
				continue;
			} 
			else
			{
				depthFirstTraverse(i);
			}
		} 
		else
		{
			continue;
		}
	}
}

/*广度优先遍历*/
void Cmap::breadthFirstTraverse(int nodeIndex)
{
	cout << nodeIndex << ":" << m_pNodeArray[nodeIndex].m_cData << " ";
	m_pNodeArray[nodeIndex].m_bIsVisited = true;

	vector<int> curVec;
	curVec.push_back(nodeIndex);
	breadthFirstTraverseImpl(curVec);
}

/*广度优先遍历函数内部算法*/
void Cmap::breadthFirstTraverseImpl(vector<int> preVec)
{
	int value = 0;
	vector<int> curVec;
	for (int j =0; j<(int)preVec.size();j++)			//对该数组中的所有结点都进行扫描，判断每个结点都与哪几个结点相连接
	{
		for (int i=0; i<m_iCapacity;i++)
		{
			getValueFromMatrix(preVec[j],i,value);
			if (value == 0)
			{
				continue;
			} 
			else
			{
				if (!m_pNodeArray[i].m_bIsVisited)
				{
					cout << i << ":" << m_pNodeArray[i].m_cData << " ";		//这其中的i表示第preVec[j]行的第i列，
																			//而第i列也就是m_pNodeArray中的下标为i的元素
					m_pNodeArray[i].m_bIsVisited = true;
					curVec.push_back(i);
				}
				else
				{
					continue;
				}
			}
		}
	}
	if (curVec.size() == 0)
	{
		return;
	} 
	else
	{
		breadthFirstTraverseImpl(curVec);
	}
}


/*普利姆生成树算法*/
void Cmap::primTree(int nodeIndex)
{
	int value=0;
	int edgeCount = 0;
	vector<int> nodeVec;							//已经遍历的所有点的集合
	vector<Edge> edgeVec;							//已经遍历的所有边的集合

	cout << m_pNodeArray[nodeIndex].m_cData << endl;
	nodeVec.push_back(nodeIndex);
	m_pNodeArray[nodeIndex].m_bIsVisited = true;

	//while(edgeCount < m_iNodeCount-1)				//最终得到的边数比所有点的数目少一个的时候，就证明已经完成了一个生成树。
	while(edgeCount < m_iCapacity-1)				//这里的m_iCapacity个人觉得还是换成m_iNodeCount为好。
	{
		int temp = nodeVec.back();					//从nodeVec中取出最尾部的元素，因为每次加进点集合的元素只有一个，而且肯定是最后一个。

		for (int i=0; i<m_iCapacity;i++)			//所以只需要遍历该元素的所有边，并将边的value值不等于0且边的终点没有被访问过的边加入集合。
		{
			getValueFromMatrix(temp,i,value);
			if (value != 0)
			{
				if (m_pNodeArray[i].m_bIsVisited)
				{
					continue;
				} 
				else
				{
					Edge edge(temp,i,value);
					edgeVec.push_back(edge);
				}
			}
		}

		//从可选边集合中找出最小的边
		int edgeIndex = getMinEdge(edgeVec);
		edgeVec[edgeIndex].m_bSelected = true;

		cout << edgeVec[edgeIndex].m_iNodeIndexA << "----" << edgeVec[edgeIndex].m_iNodeIndexB << "：";
		cout << edgeVec[edgeIndex].m_iWeightValue << endl;


		m_pEdge[edgeCount] = edgeVec[edgeIndex];					//将选出来的权值最小边放到最小生成树边的集合中
		edgeCount++;

		int nextNodeIndex = edgeVec[edgeIndex].m_iNodeIndexB;		//将选出来的最小边的另外一个顶点取出来，并放到已经遍历的点集合中
		nodeVec.push_back(nextNodeIndex);
		m_pNodeArray[nextNodeIndex].m_bIsVisited = true;

		cout << m_pNodeArray[nextNodeIndex].m_cData << endl;
	}
}

/*从边集合中获取权值最小边方法（普利姆和克鲁斯卡尔都会用到）*/
int Cmap::getMinEdge(vector<Edge> edgeVec)
{
	int minWeight = 0;
	int edgeIndex = 0;
	int i =0;
	

	for (;i<edgeVec.size();i++)				//循环检测所有没有被选择的边，取出边集合中最后一个没有被选择的边的权重和编号，该边的权重可能不是最小的。
	{
		if (!edgeVec[i].m_bSelected)		//没有被选择的边
		{
			minWeight = edgeVec[i].m_iWeightValue;			//取出边的权重
			edgeIndex = i;									//取出边的编号
		}
	}
	
	if (minWeight == 0)
	{
		return -1;
	}
	
	int j=0;
	for (;j<edgeVec.size();j++)
	{
		if (edgeVec[j].m_bSelected)
		{
			continue;
		}
		else
		{
			if (minWeight > edgeVec[j].m_iWeightValue)			//通过比较选出没有被加入最小生成树边集合中的所有边中的权值最小的边
			{
				minWeight = edgeVec[j].m_iWeightValue;
				edgeIndex = j;
			}
		}
	}
	return edgeIndex;
}

/*克鲁斯卡尔算法最小生成树*/
void Cmap::kruskalTree()
{
	int value = 0;
	int edgeCount =0;
	//定义存放结点集合的数组
	vector<vector<int>> nodeSets;


	//第一步：取出所有边
	vector<Edge> edgeVec;
	for (int i=0;i<m_iCapacity;i++)
	{
		for (int k=i+1;k<m_iCapacity;k++)
		{
			getValueFromMatrix(i,k,value);
			if (value != 0)
			{
				Edge edge(i,k,value);
				edgeVec.push_back(edge);
			}

		}
	}
	//第二步：从所有边中取出组成最小生成树的边
	//1.找到算法结束条件
	while (edgeCount < m_iNodeCount-1)
	{
		//2.从边集合中找到最小边
		int minEdgeIndex = getMinEdge(edgeVec);
		edgeVec[minEdgeIndex].m_bSelected = true;


		//3.找出最小边连接的点
		int nodeAIndex = edgeVec[minEdgeIndex].m_iNodeIndexA;
		int nodeBIndex = edgeVec[minEdgeIndex].m_iNodeIndexB;

		bool nodeAIsInSet = false;
		bool nodeBIsInSet = false;

		int nodeAInSetLabel = -1;
		int nodeBInSetLabel = -1;

		//4.找出点所在的点的集合

		for (int i=0;i<nodeSets.size();i++)
		{
			nodeAIsInSet = isInSet(nodeSets[i],nodeAIndex);
			if (nodeAIsInSet)
			{
				nodeAInSetLabel = i;
			}
			//nodeBIsInSet = isInSet(nodeSets[i],nodeBIndex);
		}

		for (int i=0;i<nodeSets.size();i++)
		{
			nodeBIsInSet = isInSet(nodeSets[i],nodeBIndex);
			if (nodeBIsInSet)
			{
				nodeBInSetLabel = i;
			}
			//nodeBIsInSet = isInSet(nodeSets[i],nodeBIndex);
		}
		//5.根据点所在集合的不同做出不同处理

		if (nodeAInSetLabel == -1 && nodeBInSetLabel == -1)
		{
			vector<int> vec; 
			vec.push_back(nodeAIndex);
			vec.push_back(nodeBIndex);
			nodeSets.push_back(vec);
		}
		else if (nodeAInSetLabel == -1 && nodeBInSetLabel != -1)
		{
			nodeSets[nodeBInSetLabel].push_back(nodeAIndex);

		}
		else if (nodeAInSetLabel != -1 && nodeBInSetLabel == -1)
		{
			nodeSets[nodeAInSetLabel].push_back(nodeBIndex);

		}
		else if (nodeAInSetLabel != -1 && nodeBInSetLabel != -1 && nodeAInSetLabel != nodeBInSetLabel )
		{
			//合并集合
			mergeNodeSet(nodeSets[nodeAInSetLabel],nodeSets[nodeBInSetLabel]);
			for (int k=nodeBInSetLabel;k<(int)nodeSets.size()-1;k++)
			{
				nodeSets[k] = nodeSets[k+1];
			}
		}
		else if (nodeAInSetLabel != -1 && nodeBInSetLabel != -1 && nodeAInSetLabel == nodeBInSetLabel )
		{
			continue;
		}
		m_pEdge[edgeCount] = edgeVec[minEdgeIndex];
		edgeCount++;

		cout << edgeVec[minEdgeIndex].m_iNodeIndexA << "--" <<edgeVec[minEdgeIndex].m_iNodeIndexB << ": ";
		cout << edgeVec[minEdgeIndex].m_iWeightValue << endl;
	}
}

/*判断顶点是否在点集合中*/
bool Cmap::isInSet(vector<int> nodeSet, int target)						
{
	for (int i=0;i<nodeSet.size();i++)
	{
		if (nodeSet[i] == target)
		{
			return true;
		}
	}
	return false;
}

/*合并两个顶点集合*/
void Cmap::mergeNodeSet(vector<int> &nodeSetA, vector<int> nodeSetB)		
{
	for (int i=0;i<nodeSetB.size();i++)
	{
		nodeSetA.push_back(nodeSetB[i]);
	}
}

demo.cpp文件

#include "Cmap.h"
#include <iostream>
using namespace std;

int main()
{
	Cmap *pMap = new Cmap(6);

	Node *pNodeA = new Node('A');
	Node *pNodeB = new Node('B');
	Node *pNodeC = new Node('C');
	Node *pNodeD = new Node('D');
	Node *pNodeE = new Node('E');
	Node *pNodeF = new Node('F');

	pMap->addNode(pNodeA);
	pMap->addNode(pNodeB);
	pMap->addNode(pNodeC);
	pMap->addNode(pNodeD);
	pMap->addNode(pNodeE);
	pMap->addNode(pNodeF);

	pMap->setValueToMatrixForUndirectedGraph(0,1,6);
	pMap->setValueToMatrixForUndirectedGraph(0,4,5);
	pMap->setValueToMatrixForUndirectedGraph(0,5,1);
	pMap->setValueToMatrixForUndirectedGraph(1,2,3);
	pMap->setValueToMatrixForUndirectedGraph(1,5,2);
	pMap->setValueToMatrixForUndirectedGraph(2,5,8);
	pMap->setValueToMatrixForUndirectedGraph(2,3,7);
	pMap->setValueToMatrixForUndirectedGraph(3,5,4);
	pMap->setValueToMatrixForUndirectedGraph(3,4,2);
	pMap->setValueToMatrixForUndirectedGraph(4,5,9);


	pMap->printMatrix();

	cout << "普利姆算法的结果：" <<endl;
	pMap->primTree(0);

	cout << "克鲁斯卡尔算法的结果：" <<endl;
	pMap->kruskalTree();


	//cout << endl;
	//pMap->depthFirstTraverse(0);

	//pMap->resetNode();
	//cout << endl;
	//cout << endl;
	//pMap->breadthFirstTraverse(0);
	//cout << endl;

	delete pMap;
	pMap = NULL;
	
	system("pause");
	return 0;
}