数据结构之图 篇二——普利姆算法与克鲁斯算法实现最小生成树

最新推荐文章于 2022-06-03 16:44:58 发布
最新推荐文章于 2022-06-03 16:44:58 发布
阅读量323 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44566432/article/details/106268535
版权

最小生成树

 

普里姆算法（Prim算法）

是图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex (graph theory)），且其所有边的权值之和亦为最小。该算法于1930年由捷克数学家沃伊捷赫·亚尔尼克（英语：Vojtěch Jarník）发现；并在1957年由美国计算机科学家罗伯特·普里姆（英语：Robert C. Prim）独立发现；1959年，艾兹格·迪科斯彻再次发现了该算法。因此，在某些场合，普里姆算法又被称为DJP算法、亚尔尼克算法或普里姆－亚尔尼克算法。

https://baike.baidu.com/item/Prim/10242166?fromtitle=%E6%99%AE%E9%87%8C%E5%A7%86%E7%AE%97%E6%B3%95&fromid=4255724#3

下面是算法的代码实现 

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_iCapacity-1)
	{
		int temp = nodeVec.back();
		for (int i = 0; i < m_iCapacity; i++)
		{
			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;
	}
}

 

Kruskal算法

是一种用来查找最小生成树的算法，由Joseph Kruskal在1956年发表。用来解决同样问题的还有Prim算法和Boruvka算法等。三种算法都是贪心算法的应用。和Boruvka算法不同的地方是，Kruskal算法在图中存在相同权值的边时也有效。

https://baike.baidu.com/item/%E5%85%8B%E9%B2%81%E6%96%AF%E5%8D%A1%E5%B0%94%E7%AE%97%E6%B3%95/4455899

下面是算法的代码实现：

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_iCapacity - 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 < (int)nodeSets.size(); i++)
		{
			nodeAIsInSet = isInSet(nodeSets[i], nodeAIndex);
			if (nodeAIsInSet)
			{
				nodeAInSetLabel = i;	
			}
		}
		
		for (int i = 0; i < (int)nodeSets.size(); i++)
		{
			nodeBIsInSet = isInSet(nodeSets[i], nodeBIndex);
			if (nodeBIsInSet)
			{
				nodeBInSetLabel = i;	
			}
		}	
			
	//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(); 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;
	}
}

 

下面是一个上面两种算法的应用，代码比较多，预警提示！！！

1、Edge.h

#ifndef EDGE_H
#define EDGE_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

2、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;
}

3、Node.h

#ifndef NODE_H
#define NODE_H
 
class Node
{
public:
	Node(char data = 0);
	char m_cData;
	bool m_bIsVisited;
	
};

#endif

4、Node.cpp

#include "Node.h"
 
Node::Node(char data)
{
	m_cData = data;
	m_bIsVisited = false;
}

5、CMap.h

#ifndef CMAP_H
#define CMAP_H

#include <vector>
#include "Node.h"
#include "Edge.h" 
#include <iostream>
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);		//广度优先遍历实现函数
	
	int getMinEdge(vector<Edge> edgeVec);	//获取最小边
	bool isInSet(vector<int> nodeSet, int target);	//判断顶点是否在集合中
	void mergeNodeSet(vector<int> &nodeSetA, vector<int> nodeSetB);	//合并两个顶点集合 
	 	
private:
	int m_iCapacity;	//图片可容纳的顶点数
	int m_iNodeCount;	//已添加的顶点数
	Node *m_pNodeArray;	//存放顶点数组
	int *m_pMatrix;		//存放邻接矩阵 
	
	Edge *m_pEdge;
	
};

#endif

6、CMap.cpp

#include "CMap.h"
#include <iostream>
using namespace std;
#include <vector>
#include <cstring>
 
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));	
//	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_pNodeArray;
	delete []m_pMatrix;
	delete []m_pEdge;
}
 
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;
	}
} 
 
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;
}
 
 
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;
}
 
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::printMatrix()
{
	for (int i = 0; i < m_iCapacity; i++)
	{
		for (int k = 0; k < m_iCapacity; k++)
		{
			cout << m_pMatrix[i * m_iCapacity + k] << " ";
		}
		cout << endl;
	}
}
 
//深度优先遍历 
void CMap::depthFirstTraverse(int nodeIndex)
{
	int value = 0;
	
	cout << 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 << 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)
			{
				if (m_pNodeArray[i].m_bIsVisited)
				{
					continue;
				}
				else
				{
					cout << m_pNodeArray[i].m_cData << " ";
					m_pNodeArray[i].m_bIsVisited = true;
					
					curVec.push_back(i);
				}
			}
		}
	}
	
	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_iCapacity-1)
	{
		int temp = nodeVec.back();
		for (int i = 0; i < m_iCapacity; i++)
		{
			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 = 0; i < (int)edgeVec.size(); i++)
	{
		if (!edgeVec[i].m_bSelected)
		{
			minWeight = edgeVec[i].m_iWeightValue;
			edgeIndex = i;
			break;
		}
	}
	
	if (minWeight == 0)
	{
		return -1;
	}
	
	for ( ; i< (int)edgeVec.size(); i++)
	{
		if (edgeVec[i].m_bSelected)
		{
			continue; 
		}	
		else
		{
			if (minWeight > edgeVec[i].m_iWeightValue)
			{
				minWeight = edgeVec[i].m_iWeightValue;
				edgeIndex = i;
			}
		}
	}
	
	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_iCapacity - 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 < (int)nodeSets.size(); i++)
		{
			nodeAIsInSet = isInSet(nodeSets[i], nodeAIndex);
			if (nodeAIsInSet)
			{
				nodeAInSetLabel = i;	
			}
		}
		
		for (int i = 0; i < (int)nodeSets.size(); i++)
		{
			nodeBIsInSet = isInSet(nodeSets[i], nodeBIndex);
			if (nodeBIsInSet)
			{
				nodeBInSetLabel = i;	
			}
		}	
			
	//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(); 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 < (int)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 < (int)nodeSetB.size(); i++)
	{
		nodeSetA.push_back(nodeSetB[i]);
	} 
}

7、main.cpp

#include <iostream>
#include "Edge.h"
#include "Node.h"
#include "CMap.h"
using namespace std;

/*
			A
		  / | \ 
		B---F---E
		\	/\	/
		  C----D

A B C D E F
0 1 2 3 4 5

A-B	6,	A-E	5,	A-F 1
B-C	3, 	B-F	2
C-F 8, 	C-D	7
D-F	4, 	D-E	2
E-F	9

*/ 		  

int main(int argc, char** argv) 
{
	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, 3);
	pMap->setValueToMatrixForUndirectedGraph(3, 4, 2);
	pMap->setValueToMatrixForUndirectedGraph(4, 5, 9);
	
	cout << "普利姆算法：" << endl;
	pMap->primTree(0);
	cout << endl; 
	
	cout << "克鲁斯算法：" << endl;
	pMap->kruskalTree();
	cout << endl;

	return 0;
}

 

哟米 2000
关注
专栏目录
数据结构之普利姆算法思想和实践
06-26
普利姆算法（Prim's Algorithm）是数据结构领域中一种用于寻找加权无向图的最小生成树（Minimum Spanning Tree, MST）的经典算法。在实际应用中，最小生成树问题常常出现在网络设计、资源分配等领域，比如构建成本...
图的最小生成树之普里姆和克鲁斯卡尔算法
mrslxw的博客
09-18 2316
普里姆（Prim）和克鲁斯卡尔（Kruskal）算法 这两种算法都是来求图的最小生成树，先来张图的图片吧（来源于书上） 普里姆算法 从图的一个顶点出发，寻找到与该顶点构成的权值最小的邻接顶点，然后将该邻接顶点存放到，一该顶点数字标识符为索引的数组下，且将读到的权值存入权值数组中（无论有无权值）来标记顶点已加入生成树中；就这样依次循环。 该算法中由于循环嵌套非常明显，经过估算其时间复杂度为 ...
最小生成树算法（普里姆算法和克鲁斯卡尔算法）
zhichao.yan的博客
10-25 3538
什么是生成树？ 一个连通图的生成树是一个极小的连通子图，它含有图中全部的n个顶点，但是只有足以构成一棵树的n-1条边。 理解： 连通图是属于无向图的范畴，有向图的连通子图叫强连通图 它含有n个全部顶点，只有n-1条，将n个顶点连起来至少要n-1条边 少于n-1条边连不起来，那么则无法连通。比如10个点直线连起来至少中间要有9条边 多于n-1条边会形成环，是连通图，但是不是极小的连通子图...
最小生成树(克鲁斯卡尔算法)
IT1995的博客
02-26 7028
最小生成树(克鲁斯卡尔算法)
【数据结构】图的最小生成树（普里姆Prim算法、克鲁斯卡尔Kruskal算法）（C语言）
weixin_51450101的博客
02-19 5849
一个连通图的生成树是指一个极小连通子图，它含有图中的全部顶点，但只有足以构成一棵树的 n-1 条边。在一个连通网的所有生成树中，各边代价之和最小的那棵生成树称为该连通网最小代价生成树（MST），简称为最小生成树。 利用普里姆（Prim）算法和克鲁斯卡尔（Kruskal）算法可以生成一个连通网的最小代价生成树。
最小生成树算法：普里姆算法和克鲁斯卡尔算法
热门推荐
祁东握力的博客
10-16 2万+
普里姆算法—Prim算法 算法思路： 从已选顶点所关联的未选边中找出权重最小的边，并且生成树不存在环。 其中，已选顶点是构成最小生成树的结点，未选边是不属于生成树中的边。 （普里姆算法与求最短路径的迪杰斯塔拉算法思想很类似） 下面我们对下面这幅图求其最小生成树： 假设我们从顶点v1开始，所以我们可以发现（v1,v3）边的权重最小，所以第一个输出的边就是：v1—v3=1: ...
数据结构最小生成树算法
03-20
普利姆算法（Prim's Algorithm）和克鲁斯卡尔算法（Kruskal's Algorithm）是两种常用的求解最小生成树的方法。 1. **普利姆算法**： - 普利姆算法从一个起始顶点开始，逐步添加边，每次添加的边都是当前生成树与图...
C实现最小生成树（普利姆算法）
06-03
本文将深入探讨如何使用C语言实现普利姆算法来构建最小生成树。 普利姆算法是一种贪心策略，它的基本思想是从一个顶点开始，逐步增加边，每次添加一条与当前树形成最小权值边的边，直到连接所有顶点。以下为普利姆...
数据结构课程设计之图的遍历和生成树求解
最新发布
10-14
数据结构课程设计中，图的遍历和生成树求解是重要的主题，涉及到图的存储结构、遍历算法以及最小生成树的计算。以下是这些知识点的详细说明： 1. **图的存储结构**： - **邻接矩阵**：对于无向图，邻接矩阵是一个n...
图的最小生成树，克鲁斯卡尔算法，普利姆算法
09-26
图的最小生成树是图论中的一个重要概念，用于解决如何在连接所有顶点的无环加权图中找到边权重总和最小的树形结构。这个任务在许多实际问题中都有应用，比如设计网络、公路规划等。在这个场景下，我们将深入探讨两种...
利用普利姆算法求最小生成树
01-06
对任意给定的网和起点，用PRIM算法的基本思想求解出所有的最小生成树。
图的最小生成树 普里姆算法+克鲁斯卡尔算法
09-15
用C++实现的图的建立 以及用普里姆算法和克鲁斯卡尔算法求图的最小生成树
两种最小生成树的方法——普里姆算法、克鲁斯卡尔算法
三粒花生米的博客
01-06 9097
一、最小生成树的概念 在连通网的所有生成树中，所有边的代价和最小的生成树。 二、MST性质 构建最小生成树的算法有多种，比如普里姆算法、克鲁斯卡尔算法。其中多数算法利用了最小生成树的下列一种简称MST的性质。 1、性质 假设N=( V , { E } )是一个连通网，U是顶点集V的一个非空子集。若（u，v）是一条具有最小权值的边，其中u∈U，v∈V-U，则必存在一颗包含边（u，v）的最小生成树。 图1 连通图N 2、...
普利姆算法和克鲁斯卡尔算法求解最小生成树
如何心安理得的在老板眼皮下摸鱼
09-30 2919
Q：最小生成树有什么用？ A：譬如我要去五个城市旅游，每两个城市之间可能有路也可能没有，路的距离可能一样也可能不一样，随机从一个城市出发，我想要把每个城市走一遍，怎么样走过的路距离最短，比如我想从上海出发，要走遍其他城市，要怎样确定一条路径最短，这就是最小生成树的作用。 求解最小生成树有两种基础算法：普利姆算法和克鲁斯卡尔算法。 Q: 如何保证最小生成树唯一？ A： 所有边的...
菜鸟笔记之数据结构（23）
lb4f2525的博客
11-09 179
数据结构与算法—常用十种算法7克鲁斯卡尔算法（Kruskal） 声明：以下是学的尚硅谷网课并结合网上资料所记的笔记。可能会有一些错误，发现了会修改。 克鲁斯卡尔算法（Kruskal） 应用场景-公交站问题 算法介绍 克鲁斯卡尔（Kruskal）算法，是用来求加权连通图的最小生成树的算法。 基本思想：按照权值从大到小的顺序选择n-1条边，并保证这n-1条边不构成回路。 具体做法：首先构造一个只含n个顶点的森林，然后按权值从小到大从连通网中选择边加入到森林中，并使森林中不产生回路，直至森林变成一棵树为止 。
两种构造最小生成树的算法（普里姆算法，克鲁斯卡尔算法）
weixin_44757834的博客
07-30 1527
（一）普里姆算法 普里姆算法求最小生成树：从生成树中只有一个顶点开始，到定点全部进入生成数为止； 2.克鲁斯卡尔算法。 思想：将所有边按其权值从小到大排一遍，从小到大依次选取边，加入最小生成树中，若加入此边后不会产生回路，则将此边加入，否则则舍去，遍历一遍所有的边。可通过并查集判断是否构成回路。 例题：HDU1863 畅通工程 题意： 省政府“畅通工...
数据结构（Java）最小生成树（普里姆、克鲁斯卡尔算法）
萌萌虎的博客
06-03 2309
最小生成树(Minimum Cost Spanning Tree)，简称MST。求最小生成树的算法主要是普里姆算法和克鲁斯卡尔算法 1)有胜利乡有7个村庄(A, B, C, D, E, F, G) ，现在需要修路把7个村庄连通prim算法的解析： 比如我们从G点出发，标记已访问，用temp变量存储已访问的顶点， temp.add(G) -> {G} 首先找出与G邻接且二者间权最小并且未被访问的点，也就是 A，
普里姆算法、克鲁斯卡尔算法求图的最小生成树
闻风听雨的博客
07-28 3356
本文所有代码都基于Java实现图的存储和创建一文所实现的带权无向图 普里姆算法 普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。意即由此算法搜索到的边子集所构成的树中，不但包括了连通图里的所有顶点（英语：Vertex (graph theory)），且其所有边的权值之和亦为最小。 Prim算法构造最下生成树的过程如下图所示： 初始时从图中任取一顶点（如顶点A）加入树T，此时树中只有一个顶点，之后选择一个与当前T中顶点集合距离最近的顶点，并将该顶点和相应的边加入T，每次操作
图的最小生成树（普里姆和克鲁斯卡尔）算法
qq_43607916的博客
07-05 5589
最小生成树 文章的目录如下： 最小生成树的相关概念 普里姆算法 克鲁斯卡尔算法 1.最小生成树 首先要知道什么是最小生成树，这里的最小指的是图的生成树的权值之和最小，最小生成树可由以下几点的概念组成： 一个图的生成树集合当中权值之和最小的生成树，可以有一种，也可以有多种，这与图本身结构有关。 包括了图中的所有节点，所有节点之间都有边，但是没有连通图； 就是有 N个顶点 有N-1个边； 就是一个连通图的极小连通子图（它包含图中的所有顶点，并且只含有尽可能少的边。），这意味着对于生成树来说，若看
克鲁斯卡尔与普利姆算法实现——图论在C语言中的应用
"本文主要介绍了两种经典的数据结构算法在图论中的应用——克鲁斯卡尔算法(Kruskal's Algorithm)和普利姆算法(Prim's Algorithm)，这两种算法主要用于寻找图的最小生成树。" 克鲁斯卡尔算法是解决加权无向图中找到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值