<C/C++图>最小生成树：Prim算法

最新推荐文章于 2024-05-20 22:12:48 发布
最新推荐文章于 2024-05-20 22:12:48 发布
阅读量3.6k 收藏 7
点赞数 1
文章标签： 算法导论 数据结构 kruskal prim 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EbowTang/article/details/45118983
版权

一，最小生成树算法基本概念

最小生成树是数据结构中图的一种重要应用，它的要求是从一个有n个节点的带权完全图中选择n－1条边并使这个图仍然连通（也即得到了一棵生成树）,同时还要考虑使树的权之和最小。最小生成树可以用,Kruskal（克鲁斯卡尔）算法或Prim（普里姆）算法求出。

1，Prim算法

1),算法简单描述:

1).输入：一个加权连通图，其中顶点集合为V，边集合为E；

2).初始化：Vnew = {x}，其中x为集合V中的任一节点（起始点），Enew = {},为空；

3).重复下列操作，直到Vnew = V：

a.在集合E中选取权值最小的边<u, v>，其中u为集合Vnew中的元素，而v不在Vnew集合当中，并且v∈V（如果存在有多条满足前述条件即具有相同权值的边，则可任意选取其中之一）；

b.将v加入集合Vnew中，将<u, v>边加入集合Enew中；

4).输出：使用集合Vnew和Enew来描述所得到的最小生成树

2),下面对算法的图例描述:

绿色顶点及边表示：已经被选中为最小生成树中的顶点

淡蓝色顶点及边表示：当前距离已选中的顶点中的最小权值边及其相连的顶点

蓝色表示顶点及边表示：当前已经选中顶点可达的顶点或者边

图例说明不可选可选已选（Vnew）
 

此为原始的加权连通图。每条边一侧的数字代表其权值。---

1，选取任意顶点为起始点，比如D。,
2，顶点A、B、E和F通过单条边与D相连。A是距离D最近的顶点，因此将A及对应边AD以高亮表示。		C, GA, B, E, FD
 

1，下一个顶点为距离D或A最近的顶点。B距D为9，距A为7，E为15，F为6。因此，F距D或A最近，因此将顶点F与相应边DF以高亮表示。C, GB, E, FA, D
算法继续重复上面的步骤。距离A为7的顶点B被高亮表示。CB, E, GA, D, F
 

在当前情况下，可以在C、E与G间进行选择。C距B为8，E距B为7，G距F为11。E最近，因此将顶点E与相应边BE高亮表示。无C, E, GA, D, F, B
 

这里，可供选择的顶点只有C和G。C距E为5，G距E为9，故选取C，并与边EC一同高亮表示。无C, GA, D, F, B, E

顶点G是唯一剩下的顶点，它距F为11，距E为9，E最近，故高亮表示G及相应边EG。无GA, D, F, B, E, C

现在，所有顶点均已被选取，图中绿色部分即为连通图的最小生成树。在此例中，最小生成树的权值之和为39。无无A, D, F, B, E, C, G


2，Kruskal算法

Kruskal算法与Prim算法的不同之处在于，Kruskal在找最小生成树结点之前，需要对所有权重边做从小到大排序。将排序好的权重边依次加入到最小生成树中，如果加入时产生回路就跳过这条边，加入下一条边。当所有结点都加入到最小生成树中之后，就找出了最小生成树。

1）.算法简单描述

1).记Graph中有v个顶点，e个边

2).新建图Graphnew，Graphnew中拥有原图中相同的e个顶点，但没有边

3).将原图Graph中所有e个边按权值从小到大排序

4).循环：从权值最小的边开始遍历每条边 直至图Graph中所有的节点都在同一个连通分量中

                if 这条边连接的两个节点于图Graphnew中不在同一个连通分量中

                                         添加这条边到图Graphnew中

2),下面对算法的图例描述:

（每次所选的边都要与原所选边进行是否为圈的判断）

首先第一步，我们有一张图Graph，有若干点和边 

 

将所有的边的长度排序，用排序的结果作为我们选择边的依据。这里再次体现了贪心算法的思想。资源排序，对局部最优的资源进行选择，排序完成后，我们率先选择了边AD。这样我们的图就变成了右图

 

 

 

在剩下的变中寻找。我们找到了CE。这里边的权重也是5

依次类推我们找到了6,7,7，即DF，AB，BE。

下面继续选择， BC或者EF尽管现在长度为8的边是最小的未选择的边。但是现在他们已经连通了（对于BC可以通过CE,EB来连接，类似的EF可以通过EB,BA,AD,DF来接连）。所以不需要选择他们。类似的BD也已经连通了（这里上图的连通线用红色表示了）。

最后就剩下EG和FG了。当然我们选择了EG。最后成功的图就是右：

 



二，C++模板实现

1，Graph.h代码实现如下：

#include "stdafx.h"
#include "iostream"
#include "queue"
using namespace std;

template<class DistType/*边的权值的类型*/> 
class Edge//边的定义
{
public:
	Edge(int dest, DistType weight)
	{
		m_nposTable=dest;
		m_distWeight=weight; 
		m_pnext=NULL;
	}
	~Edge()
	{

	}
public:
	int m_nposTable;//该边的目的顶点在顶点集中的位置
	DistType m_distWeight;//边的权重值
	Edge<DistType> *m_pnext;//下一条边（注意不是下一个顶点，因为m_nposTable已经知道了这个顶点的位置）
};
//声明
template<class NameType/*顶点集名字类型*/, class DistType/*距离的数据类型*/> class Graph;

template<class NameType/*顶点集名字类型*/, class DistType/*距离的数据类型*/> 
class Vertex//顶点的定义
{
public:
	Vertex()
	{
		padjEdge=NULL;
		m_vertexName=0;
	}
	~Vertex()
	{
		Edge<DistType> *pmove = padjEdge;
		while (pmove)
		{
			padjEdge = pmove->m_pnext;
			delete pmove;
			pmove = padjEdge;
		}
	}

private:
	friend class Graph<NameType,DistType>;//允许Graph类任意访问
	NameType m_vertexName;//顶点中的数据内容
	Edge<DistType> *padjEdge;//顶点的邻边

};


template<class NameType/*顶点集名字类型*/, class DistType/*距离的数据类型*/> 
class Graph
{
public:
	Graph(int size = m_nDefaultSize/*图顶点集的规模*/)
	{
		m_pVertexTable = new Vertex<NameType, DistType>[size];  //为顶点集分配内存
		if (m_pVertexTable == NULL)
		{
			exit(1);
		}
		m_numVertexs=0;
		m_nmaxSize=size;
		m_nnumEdges=0;
	}

	~Graph()
	{
		Edge<DistType> *pmove;
		for (int i=0; i < this->m_numVertexs; i++)
		{
			pmove = this->m_pVertexTable[i].padjEdge;
			if (pmove){
				this->m_pVertexTable[i].padjEdge = pmove->m_pnext;
				delete pmove;
				pmove = this->m_pVertexTable[i].padjEdge;
			}
		}
		delete[] m_pVertexTable;
	}
	int GetNumEdges()
	{//获得边的数目
		return m_nnumEdges/2;
	}
	int GetNumVertexs()
	{//获得顶点数目
		return m_numVertexs;
	}

	bool IsGraphFull() const
	{     //图满的?
		return m_nmaxSize == m_numVertexs;
	}
	//在顶点集中位置为v1和v2的顶点之间插入边
	bool InsertEdge(int v1, int v2, DistType weight=m_Infinity); 
	//插入顶点名字为vertex的顶点
	bool InsertVertex(const NameType vertex);  
	//打印图
	void PrintGraph();   
	//顶点v到其他各个顶点的最短路径（包括自身）
	void Dijkstra(int v, DistType *shotestpath);
	//获取顶点集中位置为v1和v2的顶点之间边的权重值
	DistType GetWeight(int v1, int v2); 
	//获得在顶点集中的位置为v的顶点的名字
	NameType GetVertexValue(int v);
	//用该顶点的名字来寻找其在顶点集中的位置
	int GetVertexPosTable(const NameType vertex);  


	//得到顶点v的邻点中权值最小的那条边
	Edge<DistType> *GetMin(int v, int *visited);   
	//最小生成树
	void Prim(Graph<NameType, DistType> &graph);  

	//深度搜索优先
	void DFS(int v, int *visited);      
	void DFS();
	//广度优先搜索
	void BFS(int v, int *visited);
	void BFS();
	//获取第v个顶点的名字（或者说内容）
	NameType GetVertexName(int v);   
	//获得顶点v的第一个相邻顶点，如果没有就返回-1
	int GetFirst(int v);       
	//获得顶点v1的邻点v2后的邻点
	int GetNext(int v1, int v2);

private:
	Vertex<NameType, DistType> *m_pVertexTable;   //顶点集
	int m_numVertexs;//图中当前的顶点数量
	int m_nmaxSize;//图允许的最大顶点数
	static const int m_nDefaultSize = 10;       //默认的最大顶点集数目
	static const DistType m_Infinity = 65536;  //边的默认权值（可以看成是无穷大）
	int m_nnumEdges;//图中边的数目
	
};


//返回顶点vertexname在m_pVertexTable(顶点集)中的位置
//如果不在顶点集中就返回-1
template<class NameType, class DistType> 
int Graph<NameType, DistType>::GetVertexPosTable(const NameType vertexname)
{
	for (int i=0; i < this->m_numVertexs; i++)
	{
		if (vertexname == m_pVertexTable[i].m_vertexName)
		{
			return i;
		}
	}
	return -1;
}

//打印图中的各个顶点及其链接的边的权重
template<class NameType, class DistType> 
void Graph<NameType, DistType>::PrintGraph()
{
	Edge<DistType> *pmove;
	for (int i=0; i<this->m_numVertexs; i++)
	{
		cout << this->m_pVertexTable[i].m_vertexName << "->";
		pmove = this->m_pVertexTable[i].padjEdge;
		while (pmove)
		{
			cout << pmove->m_distWeight << "->" << this->m_pVertexTable[pmove->m_nposTable].m_vertexName << "->";
			pmove = pmove->m_pnext;
		}
		cout << "NULL" << endl;
	}
}
//获得在顶点集中的位置为v的顶点的名字
template<class NameType, class DistType> 
NameType Graph<NameType, DistType>::GetVertexValue(int v)
{
	if (v<0 || v>=this->m_numVertexs)
	{
		cerr << "查找的顶点位置参数有误，请检查！" <<endl;
		exit(1);
	}
	return m_pVertexTable[v].m_vertexName;

}
//返回顶点v1和v2之间的边权值，
//如果没有直接相连（即不是一条边直接相连）则返回无穷大
template<class NameType, class DistType> 
DistType Graph<NameType, DistType>::GetWeight(int v1, int v2)
{
	if (v1>=0 && v1<this->m_numVertexs && v2>=0 && v2<this->m_numVertexs)
	{
		if (v1 == v2)
		{
			return 0;
		}
		Edge<DistType> *pmove = m_pVertexTable[v1].padjEdge;
		while (pmove)
		{
			if (pmove->m_nposTable == v2)
			{
				return pmove->m_distWeight;
			}
			pmove = pmove->m_pnext;
		}
	}
	
	return m_Infinity;	
}

//顶点依次插入到分配好的顶点集中
template<class NameType, class DistType> 
bool Graph<NameType, DistType>::InsertVertex(const NameType vertexname)
{
	if (IsGraphFull())
	{
		cerr<<"图已经满，请勿再插入顶点！"<<endl;
		return false;
	}else
	{
		this->m_pVertexTable[this->m_numVertexs].m_vertexName = vertexname;
		this->m_numVertexs++;
	}
	
	return true;
}

//在顶点集位置为v1和v2的顶点之间插入权值为weght的边（务必保持输入的准确性，否则.....）
template<class NameType, class DistType> 
bool Graph<NameType, DistType>::InsertEdge(int v1, int v2, DistType weight)
{
	if (v1 < 0 && v1 > this->m_numVertexs && v2 < 0 && v2 > this->m_numVertexs)
	{
		cerr<<"边的位置参数错误，请检查！ "<<endl;
		return false;
	}
	else
	{
		Edge<DistType> *pmove = m_pVertexTable[v1].padjEdge;
		if (pmove == NULL)//如果顶点v1没有邻边
		{ //建立顶点v1的第一个邻边(该邻边指明了目的顶点)
			m_pVertexTable[v1].padjEdge = new Edge<DistType>(v2, weight);
			m_nnumEdges++;//图中边的数目
			return true;
		}else//如果有邻边
		{
			while (pmove->m_pnext)
			{
				pmove = pmove->m_pnext;
			}
				pmove->m_pnext = new Edge<DistType>(v2, weight);
				m_nnumEdges++;//图中边的数目
				return true;
		}
	}
}


template<class NameType, class DistType>
void Graph<NameType, DistType>::Dijkstra(int v, DistType *shPath)
{
	int num =GetNumVertexs();
	int *visited = new int[num];
	for (int i=0; i < num; i++)
	{//初始化
		visited[i] = 0;//未访问
		shPath[i] = this->GetWeight(v, i);//顶点v（当前中间点）到各个相邻顶点的边权值，其他情况返回无穷大
	}

	visited[v] = 1;//第v个顶点初始化为被访问，并以他为中点点开始找最短路径

	for (int i = 1; i < num; i++)
	{
		DistType min = this->m_Infinity;
		int u=0;
		
		//寻找新的中间点u，依据就是数组中权值最小的那个点的位置（且没被访问过）
		for (int j=0; j < num; j++)
		{   
			if (!visited[j])
			{
				if (shPath[j]<min)
				{
					min = shPath[j];//获得当前shPath数组中的最小边权重
					u = j;//用u来记录获取最小值时的顶点位置,即新的中间点
				}
			}
		}

		visited[u] = 1;//已经确定的最短路径

		//以u为中间点寻找顶点v到顶点w的最短路径
		for (int w=0; w < num; w++)
		{  
			DistType weight = this->GetWeight(u, w);//顶点u（当前中间点）到各个相邻顶点的边权值，其他情况返回无穷大
			if (!visited[w] && weight != this->m_Infinity )
			{
				if ( shPath[u]+weight < shPath[w] )
				{
					shPath[w] = shPath[u] + weight;//更新顶点v到w的最短路径值
				}
			}
		}
	}
	delete[] visited;
}



//获得顶点v1的邻点v2后的邻点
template<class NameType, class DistType> 
int Graph<NameType, DistType>::GetNext(int v1, int v2)
{
	if (-1 != v1)
	{
		Edge<DistType> *pmove = this->m_pVertexTable[v1].padjEdge;
		while (NULL != pmove->m_pnext)
		{
			if (pmove->m_nposTable==v2)
			{
				return pmove->m_pnext->m_nposTable;
			}
			pmove = pmove->m_pnext;
		}        
	}
	return -1;
}

//从第v个顶点开始深度遍历
template<class NameType, class DistType> 
void Graph<NameType, DistType>::DFS(int v, int *visited)
{
	cout << "->" << this->GetVertexName(v);
	visited[v] = 1;
	int firstVertex = this->GetFirst(v);//获得顶点v的第一个相邻顶点，若没有则返回-1
	while (-1 != firstVertex)
	{
		if (!visited[firstVertex])//如果没有访问过
		{
			cout << "->" << this->GetWeight(v, firstVertex);//获得顶点v及其邻点firstVertex之间的权值
			DFS(firstVertex, visited);
		}
		firstVertex = this->GetNext(v, firstVertex);//获得顶点v的邻点firstVertex后的邻点，如果没有就返回-1
	}
}

template<class NameType, class DistType> 
void Graph<NameType, DistType>::DFS()
{
	int *visited = new int[this->m_numVertexs];
	for (int i=0; i<this->m_numVertexs; i++)
	{
		visited[i] = 0;
	}
	cout << "head";
	DFS(0, visited);//从第一个顶点开始遍历
	cout << "--->end";
}

template<class NameType, class DistType> 
void Graph<NameType, DistType>::BFS()
{
	int *visited = new int[this->m_numVertexs];
	for (int i=0; i<this->m_numVertexs; i++)
	{
		visited[i] = 0;
	}
	cout << "head";
	BFS(0, visited);//从第一个顶点开始遍历
	cout << "--->end";
}

//从第v个顶点开始广度遍历
template<class NameType, class DistType> 
void Graph<NameType, DistType>::BFS(int v, int *visited)
{
	cout << "->" << this->GetVertexName(v);
	visited[v]=1;
	queue<int> que;//=new queue<int>[this->GetNumVertexs()];
	que.push(v);//进队（队列的末端）
	while (!que.empty())
	{
		v=que.front();//出队首元素
		que.pop();//删除队首元素
		int firstvertex=GetFirst(v);
		while(firstvertex != -1)
		{
			if (!visited[firstvertex])
			{
				cout << "->" << this->GetWeight(v, firstvertex);//获得顶点v及其邻点firstVertex之间的权值
				que.push(firstvertex);
				visited[firstvertex]=1;
				cout << "->" << this->GetVertexName(firstvertex);
			}
			firstvertex=GetNext(v,firstvertex);
		}
	}
}

//获得在顶点集中的位置为v的顶点的名字
template<class NameType, class DistType> 
NameType Graph<NameType, DistType>::GetVertexName(int v)
{
	if (v<0 || v>=this->m_numVertexs)
	{
		cerr << "查找的顶点位置参数有误，请检查！" <<endl;
		exit(1);
	}
	return m_pVertexTable[v].m_vertexName;

}

//获得顶点v的第一个相邻顶点，如果没有就返回-1
template<class NameType, class DistType> 
int Graph<NameType, DistType>::GetFirst(int v)
{
	if (v<0 || v>=this->m_numVertexs)
	{
		return -1;
	}
	Edge<DistType> *ptemp = this->m_pVertexTable[v].padjEdge;
	return m_pVertexTable[v].padjEdge ? m_pVertexTable[v].padjEdge->m_nposTable : -1;
}






template<class NameType, class DistType> 
Edge<DistType>* Graph<NameType, DistType>::GetMin(int v, int *visited)
{
	Edge<DistType> *pmove = this->m_pVertexTable[v].padjEdge; 
	Edge<DistType> *ptemp = new Edge<DistType>(0, this->m_Infinity);
	Edge<DistType> *pmin = ptemp;
	while (pmove)
	{
		if (!visited[pmove->m_nposTable] && pmin->m_distWeight>pmove->m_distWeight){
			pmin = pmove;
		}
		pmove = pmove->m_pnext;
	}
	if (pmin == ptemp)
	{
		delete ptemp;
		return NULL;
	}
	delete ptemp;
	return pmin;
}

template<class NameType, class DistType> 
void Graph<NameType, DistType>::Prim(Graph<NameType, DistType> &graphprim)
{ 
	int *nodeVertex = new int[this->m_numVertexs];    //用来存储被访问过的顶点
	int *visited = new int[this->m_numVertexs];//设置顶点被访问过与否
	int count = 0;
	Edge<DistType> *ptemp1;
	Edge<DistType> *ptemp2 = new Edge<DistType>(0, this->m_Infinity);
	Edge<DistType> *pmin;
	int min=0;
	//初始化最小生成树
	for (int i=0; i<this->m_numVertexs; i++)
	{
		graphprim.InsertVertex(this->m_pVertexTable[i].m_vertexName);
		nodeVertex[i] = 0;
		visited[i] = 0;
	}
	visited[0] = 1;//从第一个顶点开始，并标记为以访问
	while(++count < this->m_numVertexs)
	{
		pmin = ptemp2;
		pmin->m_distWeight = this->m_Infinity;

		//获得已访问顶点和未访问顶点之间的最小权值
		for (int i=0; i<count; i++){
			ptemp1 = GetMin(nodeVertex[i], visited);
			if (NULL == ptemp1)
			{
				continue;
			}
			if (pmin->m_distWeight > ptemp1->m_distWeight)
			{
				pmin = ptemp1;
				min = nodeVertex[i];            
			}
		}

		nodeVertex[count] = pmin->m_nposTable;
		visited[nodeVertex[count]] = 1;
		graphprim.InsertEdge(pmin->m_nposTable, min, pmin->m_distWeight);
		graphprim.InsertEdge(min, pmin->m_nposTable, pmin->m_distWeight);
	}

	delete ptemp2;
	delete[] nodeVertex;
	delete[] visited;
}


2，主程序代码如下：

// ConsoleAppMyGraph.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "Graph.h"
#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
	
	Graph<char *, int> graph(7);
	char *vertex[7] = {"【地大】", "【武大】", "【华科】", "【交大】", "【北大】", "【清华】", "【复旦】"};//顶点集
	for (int i=0; i<7; i++)
	{
		graph.InsertVertex(vertex[i]);
	}
	cout<<"一，图的初始化（邻结表存储）：======================================"<<endl;
	graph.PrintGraph();
	cout<<"图中顶点的数目:"<<graph.GetNumVertexs()<<endl;
	cout <<endl;


	int edge[][3] = {{0, 1, 43}/*地大到武大的距离*/, {0, 2, 12}, {1, 2, 38}, {2, 3 ,1325},
	{3, 6, 55},{4, 5, 34}, {4, 6, 248},{0,3,400},{2,6,314},{2,4,37}};    //分配距离 
	int len=sizeof(edge)/sizeof(edge[0]);
	for (int i=0; i < len; i++)
	{
		graph.InsertEdge(edge[i][0], edge[i][1], edge[i][2]);
		graph.InsertEdge(edge[i][1], edge[i][0], edge[i][2]);
	}
	cout<<"二，添加边后的图(无向图)：=================================="<<endl;
	graph.PrintGraph();
	cout<<"图中边的数目(实际上是所示边数的两倍，因为是双向的)："<<graph.GetNumEdges()<<endl;
	cout <<endl;


	cout<<"三，Dijkstra法最短路径为：=========================="<<endl;
	int shortestPath[7];//存储Dijkstra算法最短路径值
	graph.Dijkstra(0, shortestPath);
	for (int i=0; i<7; i++)
	{
		cout << graph.GetVertexValue(0) << "--->" << graph.GetVertexValue(i) 
			<< ":   " << shortestPath[i] <<endl;
	}
	cout<<endl;


	cout<<"四，图的遍历：=========================="<<endl;
	cout<<"1,DFS深度优先遍历结果："<<endl;
	graph.DFS();
	cout<<endl<<endl;
	cout<<"2,BFS广度优先遍历结果："<<endl;
	graph.BFS();
	cout<<endl<<endl;


	cout<<"五，最小生成生成树：================================="<<endl;
	Graph<char *, int> graphPrim;
	graph.Prim(graphPrim);
	cout<<"使用DFS遍历:"<<endl;
	graphPrim.DFS();
	cout<<endl<<endl;
	cout<<"使用BFS遍历:"<<endl;
	graphPrim.BFS();

	system("color 0A");
	system("pause");
	return 0;
}



3，测试结果：




参考资源：

【1】《算法导论》

【2】《百度文库》

【3】《维基百科》

【4】https://en.wikipedia.org/wiki/Kruskal%27s_algorithm

【5】https://en.wikipedia.org/wiki/Prim%27s_algorithm

【6】http://baike.baidu.com/linkurl=tHoWD0_Xcu_fSMMoQgLmwh_0nR1Uk0xfYRhd8zgVYSX8DMsHPSXRsQZhgvw7SL9NyHDrQkU7j7B80uusAZbl4PzSGZzJwxqHba_FJ7jAkApSmLUjq2PswoytLdvZpL7nWoUCR4jJp_MxGyGA06YQKf5WU6sHZNBbUePG6NiytO

【7】http://blog.csdn.net/todd911/article/details/9219937

【8】http://blog.chinaunix.net/uid-25324849-id-2182922.html

【9】http://www.cnblogs.com/rollenholt/archive/2012/04/09/2439055.html


注：

本文部分文字学习并copy自网络，代码参考并改写于《算法导论》.

如果侵犯了您的版权，请联系本人tangyibiao520@163.com，本人将及时编辑掉！



EbowTang
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
图的最小生成树之Prim算法C/C++代码实现
Ycy的博客
06-19 1928
最小生成树： 在一个连通网的所有生成树中，各边的代价之和最小的那棵生成树称 为该连通网的最小代价生成树 (Minimum Cost Spanning Tree), 简称为最小生成树。 一棵有n个顶点的生成树有且仅有n-1条边。 普里姆Prim算法 : 该算法也称“加点法”，即在辅助数组中选择权值最小的顶点加入点集合U，并用刚选择的顶点更新辅助数组中到各顶点的权值。 注：该算法与网中的边数无关， 因此适用于求稠密网的最小生成树。 以该图为例： 辅助数组如下表（k为顶点在数组中的下标）： 代码如下： （下面
C++ 最小生成树之Prim算法
ChanJose的博客
03-25 3185
一、思路： 和Kruscal类似，先从一个顶点u出发，找u的邻接顶点v，如果（u,v）权值最小且v顶点不在生成树顶点集合中（防止出现回路），则把边（u,v）存到最小生成树中；否则该顶点已经在生成树顶点集合中，舍弃该边，找权值次小的另一条边。然后，从顶点v出发，找下一条不会出现回路的边（v,w）。直到找到n-1条边。 1.假如从顶点A出发，找A的邻接顶点（不在生成树顶...
c/c++最小生成树 prim算法
05-29
洛谷原模板题p3366 题目网址： https://www.luogu.com.cn/problem/P3366
Prim算法求最小生成树，c语言实现，超详解，代码清晰
m0_74114535的博客
04-08 1073
Prim算法求最小生成树，c语言实现，超详解，代码清晰
Prim算法生成最小生成树(MST)原理及算法实现
最新发布
2301_77118121的博客
05-20 514
本实验旨在理解和掌握Prim算法的基本原理，并通过编程实现该算法，以求解给定无向加权图的最小生成树。通过本实验，能够加深对最小生成树概念的理解，并提升编程能力。
最小生成树——Prim算法（详细图解）
热门推荐
qq_62213124的博客
11-28 16万+
最小生成树的概念 在一给定的无向图G = (V, E) 中，(u, v) 代表连接顶点 u 与顶点 v 的边，而 w(u, v) 代表此的边权重，若存在 T 为 E 的子集（即）且为无循环图，使得的 w(T) 最小，则此 T 为 G 的最小生成树。最小生成树其实是最小权重生成树的简称。 ...
最小生成树算法（Prim Kruskal）
咸鱼势力登场
07-25 1万+
最小生成树算法总览 最小生成树的定义及性质 Prim（普利姆）算法[朴素Prim算法 堆优化Prim算法] Prim算法求最小生成树[朴素Prim的代码实现 堆优化Prim的代码实现] Kruskal（克鲁斯卡尔）算法[Kruskal算法求最小生成树]
Prim算法实现最小生成树
qq_44423388的博客
11-19 1万+
Prim算法求最小生成树： 1. 从任意一个顶点（假设选1）开始构造生成树，首先将顶点1加入生成树中，用一个一维数组book标记那些顶点已经加入到了生成树中。 2. 用数组dis记录生成树到各个顶点的距离。最初生成树只有1号顶点，有直连边时，数组dis中存储的就是1号顶点到该顶点的边的权值，没有直连边的时候就是无穷大(INT_MAX)，即初始化数组。 3. 从数组dis中选出离生成树最近的顶点（假设为顶点j）加入到生成树中（在数组dis中的最小值）。再以j为中间点，更新生成树到每一个非树顶点的距离，如果
最小生成树——prim算法
02-15 1万+
最小生成树(Minimum Spanning Tree,MST)是在一个给定的无向图G(V,E)中求一棵树T，使得这棵树拥有图G中的所有顶点，且所有边都是来自图G中的边，并且满足整棵树的边权之和最小。下图给出了一个图G及其最小生成树T，其中较粗的线即为最小生成树的边。可以看到，边AB、BC、BD包含了图G的所有顶点，且由它们生成的树的边权之和为6，是所有生成树中权值最小的。 最小生成树有3...
最小生成树Prim算法详解(C++)
weixin_60401853的博客
03-26 2051
最小生成树Prim算法详解(C++)
最小生成树算法之Prim(普里姆)算法
xiaoxi_hahaha的博客
07-20 2万+
最小生成树的可以通过Kruskal(克鲁斯卡尔)算法或Prim(普里姆)算法求出。 Prim算法基本介绍： Prim算法又称为"加点法"，每次找出距离(此处的距离指的是距离最小生成树的距离，若此处无法理解，可直接跳过，看完下面例子就能理解)最小的边对应的点。算法逐渐从某一个顶点s开始，逐渐将n个点纳入最小生成树中。 Prim算法基本步骤： 第一步：设图中所有顶点的集合为V，u代表已经加入最小生成树的顶点的集合，v代表未加入最小生成树的顶点的集合，最由于从某点s开始，因此u={s}，v={V-u}
Prim算法构造最小生成树
戒
03-08 4664
Prim算法 普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。 1.问题 举一个实例，画出采用Prim算法构造最小生成树的过程。 2.解析 已知图V = {…} 我们构造一棵最小生成树T 第一步：随意选取起点 第二步：在前一步的基础上寻找最小权值 第三步：继续寻找最小权值，之后以此类推，直到遍历完所有的节点。 实例： 图v如图 1.任意选择一个点 这里我们选择A点 从A点出发有两条路，一条通向B(权值为3)，一条通向D(权值为4) 我们选择权值较小的点B 此时被选中的点：A
C++算法：加权连通图的最小生成树(Prim)
攻城狮的博客
06-16 1720
在前文加权连通图的最小生成树(Kruskal)中已经用以边找点的方式实现最小生成树的生成。Prim算法也是一种常用的最小生成树算法，和Kruskal不同，Prim算法是以顶点找边实现的。
C语言实现Prim算法 —构建最小生成树
weixin_52375817的博客
12-11 1万+
介绍Prim算法前的相关概念 一、Prim算法的思想 二.1、利用图形详细解释Prim算法的思想 二.2利用图形又又解释Prim算法的思想 三、用图示结合代码中重要量进行说明 四、代码实现（用c语言）
最小生成树-Prim算法详解（含全部代码）
关注网络安全、云原生安全
11-10 3万+
目录 适用条件 测试所用图 算法详解 Prim算法代码 全部代码 实验结果 适用条件 加权连通图 测试所用图 所用原图及生成过程 其中，(a) 为原图，圆圈里面是节点的名称，边上的数字是边的权值。由实线连接的点就是集合U，即生成树在生成过程中加入的点。由虚线连接的点中不包含在集合U中的就是集合V-U，即待加入到生成树的点。虚线的变化就是在每次有节点加入集合U时，V-U中的点...
最小生成树—Prim算法
thdwx的博客
10-22 1694
我们要讨论的问题是如何在一个中找到它的最小生成树，虽然这个问题对有向图也有意义，但是处理起来更麻烦。一个无向图 G 的最小生成树就是连接 G 上所有顶点的边构成的树，且这些边的总权值最低。当且仅当图是才有最小生成树。在无向图的最小生成树中，边的条数为。最小生成树是一棵树，因为它无圈；边的总权值最低，所以它最小；包含所有顶点，所以是生成树。显然，最小生成树是包含所有顶点的最小的树。如果我们需要给一所房子里安装电路，那么这就是一个最小生成树问题。对于任意生成树，如果向树中增加一条不属于树的边。
最小生成树——Prim算法
lranqi的博客
08-11 4370
最小生成树——Prim算法详解，适用于求解边稠密图的最小生成树。以洛谷P1546 [USACO3.1]最短网络 Agri-Net为例说明Prim算法的Java实现过程。
Prim算法（C++）
qq_74156152的博客
11-13 614
需要注意的是，Prim算法要求构成的图必须是连通的。若原图不连通，则需要对每个连通分量分别运行Prim算法。此外，Prim算法的时间复杂度为O(E*logV)，其中E为边数，V为顶点数。Prim算法是一种用于解决最小生成树问题的贪心算法。该算法的主要思想是从一个顶点开始，不断向图中添加边，直到构成一棵包含所有顶点的生成树，使得树的边权之和最小。2. 若生成树中已经包含所有顶点，则算法结束；否则，从与生成树相邻的所有边中选择一条边权最小的边，将其加入生成树中。3. 重复步骤2，直到生成树包含所有顶点。
数据结构----C++实现Prim算法（贪心算法）
呵呵哒!的博客
01-31 2508
理解最小生成树的定义 生成树：连通图的生成树是包含全部顶点的一个极小连通子图 生成树的代价：在无向连通网中，生成树上各边的权值之和 最小生成树：在无向连通网中，代价最小的生成树 应用场景：在n个城市之间建造通信网络，至少要架设n-1条通信线路，而每两个城市之间架设通信线路的造价是不一样的，那么如何设计才能使得总造价最小？ Prim算法——基本思想 Prim算法：从某一个顶点开始构建生成树，每次将代价最小的新顶点纳入生成树，直到所有的顶点都纳入为止。 ...
最小生成树prim算法C语言
03-13
Prim算法是一种用于求解最小生成树的经典算法，它的基本思想是从一个顶点开始，逐步扩展生成树的边，直到覆盖所有的顶点。下面是Prim算法的C语言实现： ```c #include <stdio.h> #include <stdbool.h> #define INF 9999 #define V 5 int minKey(int key[], bool mstSet[]) { int min = INF, min_index; for (int v = 0; v < V; v++) { if (mstSet[v] == false && key[v] < min) { min = key[v]; min_index = v; } } return min_index; } void printMST(int parent[], int graph[V][V]) { printf("Edge \tWeight\n"); for (int i = 1; i < V; i++) { printf("%d - %d \t%d \n", parent[i], i, graph[i][parent[i]]); } } void primMST(int graph[V][V]) { int parent[V]; int key[V]; bool mstSet[V]; for (int i = 0; i < V; i++) { key[i] = INF; mstSet[i] = false; } key[0] = 0; parent[0] = -1; for (int count = 0; count < V - 1; count++) { int u = minKey(key, mstSet); mstSet[u] = true; for (int v = 0; v < V; v++) { if (graph[u][v] && mstSet[v] == false && graph[u][v] < key[v]) { parent[v] = u; key[v] = graph[u][v]; } } } printMST(parent, graph); } int main() { int graph[V][V] = { {0, 2, 0, 6, 0}, {2, 0, 3, 8, 5}, {0, 3, 0, 0, 7}, {6, 8, 0, 0, 9}, {0, 5, 7, 9, 0} }; primMST(graph); return 0; } ``` 这段代码实现了Prim算法的逻辑。首先定义了一个`minKey`函数，用于找到key值最小的顶点。然后定义了`printMST`函数，用于打印最小生成树的边和权重。接着是`primMST`函数，其中初始化了key、mstSet和parent数组，并进行了主要的Prim算法逻辑。最后，在`main`函数中定义了一个图的邻接矩阵，并调用`primMST`函数求解最小生成树。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值