图的应用——最小生成树（Kruskal算法）和（Prim算法）

最新推荐文章于 2023-01-31 09:45:40 发布
最新推荐文章于 2023-01-31 09:45:40 发布
阅读量759 收藏
点赞数 1
分类专栏： 数据结构的应用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35909255/article/details/57429382
版权
一、一些概念的理解：

生成树：一个连通图的生成树是原图的极小连通图，它包含原图中的所有顶点，而且有尽可能少的边。也就意味着对于生成树来说，若砍去他的一条边，就会使生成树变成一个非连通图；若给他增加一条边，就会形成图中的一个回路。

最小生成树：

1、概念：

对于一个带权的连通图（即网络），如何找出一棵生成树，使得各边上的权值总和达到最小。

2、原则：

（1）必须只使用该网络中的边来构造

（2）必须只使用且仅适用n-1条边来连接网络中的n个顶点

（3）不能使用产生回路的边

3、算法：
（1）克鲁斯卡尔算法（Kruskal）:

将各边的权值从小到大排列，依次连接符合原则且最小的边。

核心操作：father[i]

#pragma once
#include"AllHead.h"
#include<stdlib.h>
#include<search.h>
#define MAXSIZE 10 

struct EdgeNode
{
	int x;
	int y;
	int weight;
};
template<class T,class E>
class Grap
{
private:
	T *VerticesList;  //顶点元素
	E **Edge;         //动态的二维数组
	int maxVertices;  //预定最多的顶点个数
	int numVertices;  //记录元素的个数
	int numEdge;      //记录边的个数
public:
	Grap(int sz = 0):maxVertices(sz>MAXSIZE?sz:MAXSIZE),numVertices(0),numEdge(0)
	{
		int i,j;
		Edge = new E*[maxVertices];
		for(i = 0;i<maxVertices;++i)
		{
			Edge[i] = new E[maxVertices];
		}
		VerticesList = new T[maxVertices];
		for(i=0;i<maxVertices;++i)
		{
			VerticesList[i] = '#';
		}
		for(i = 0;i<maxVertices;i++)
		{
			for(j = 0;j<maxVertices;++j)
				Edge[i][j] = 0;
		}
	}
	Grap(T ar[],int sz):maxVertices(sz),numVertices(sz),numEdge(0)
	{
		int i,j;
		Edge = new E*[maxVertices];
		for(i = 0;i<maxVertices;++i)
		{
			Edge[i] = new E[maxVertices];
		}
		VerticesList = new T[maxVertices];
		for(i=0;i<maxVertices;++i)
		{
			VerticesList[i] = ar[i];
		}
		for(i = 0;i<maxVertices;i++)
		{
			for(j = 0;j<maxVertices;++j)
				Edge[i][j] = 0;
		}
	}
public:
	int GetVerticespos(T x)
	{
		int i;
		for(i = 0;i<numVertices;++i)
		{
			if(VerticesList[i] == x)
				return i;
		}
		return -1;
	}
	int NumberOfVertices()
	{return numVertices;}
	int NumberOfEdge()
	{return numEdge;}
public:
	int RemoveEdge(T x1,T x2)
	{
		int v1 = GetVerticespos(x1);
		int v2 = GetVerticespos(x2);
		if(v1 == -1||v2 == -1)
			return -1;
		Edge[v1][v2] = 0;
		Edge[v2][v1] = 0;
		--numEdge;
		return OK;
	}
	int RemoveVertex(T x)
	{
		int v = GetVerticespos(x);
		if(v == -1)
		{
			cout<<"结点不存在..."<<endl;
			return ERROR;
		}
		int i,j,tempedge = 0;
		for(int i=0; i<numVertices; ++i)
		{
			if(Edge[v][i] != 0)
				tempedge++;
		}
		VerticesList[v] = VerticesList[numVertices - 1];
		for(i = 0;i<numVertices;++i)
		{
			Edge[v][i] = Edge[numVertices - 1][i];
		}
		for(j = 0;j<numVertices;++j)
		{
			Edge[j][v] = Edge[j][numVertices - 1];
		}
		--numVertices;
		numEdge -= tempedge; 
	}
	int GetNextNeighbor(T x1,T x2)
	{
		int i;
		int v1 = GetVerticespos(x1);//头 
		int v2 = GetVerticespos(x2);//第一个子
		if(v1 == -1||v2 == -1)
		{
			cout<<"有个顶点不存在...";
			return ERROR;
		}
		if(Edge[v1][v2] == 0)
		{
			cout<<"第一条线并不存在....";
			return ERROR;
		}
		for(i = v2+1;i<numVertices;++i)
		{
			if(Edge[v1][i] == 1)
				return i;
		}
		cout<<"没有下一个顶点....";
		return -1;
	}
	int GetFirstNeighbor(T x)
	{
		int i;
		int v = GetVerticespos(x);
		if(v == -1)
		{
			cout<<"没有这个结点..."<<endl;
		}
		else
		{
			for(i=0;i<numVertices;++i)
			{
				if(Edge[v][i] == 1)
					return i;
			}
		}
		return -1;
	}
	int InsertEdge(T x1,T x2,int weight)
	{
		int v1 = GetVerticespos(x1);
		int v2 = GetVerticespos(x2);
		if(v1 != -1&&v2 != -1)
		{
			Edge[v1][v2] = weight;
			Edge[v2][v1] = weight;
			++numEdge;
			return OK;
		}
		else
			return ERROR;
	}
	int InsertVertices(T x)
	{
		if(numVertices >= maxVertices)
		{
			cout<<"空间已满(Insert)........"<<endl;
			return ERROR; 
		}
		VerticesList[numVertices++] = x;
		return OK;
	}
	void ShowGrap()
	{
		int i,j;
		cout<<"   ";
		for(i=0;i<numVertices;++i)
		{
			cout<<VerticesList[i]<<"  ";
		}
		cout<<endl;
		for(i = 0;i<numVertices;i++)
		{
			cout<<VerticesList[i]<<"  ";
			for(j = 0;j<numVertices;++j)
				cout<<Edge[i][j]<<"  ";
			cout<<endl;
		}
	}
	bool Is_Same(int father[],int i,int j)
	{
		while(father[i] != i)
		{
			i = father[i];
		}
		while(father[j] != j)
		{
			j = father[j];
		}
		return i == j;
	}
	void Mark_Same(int father[],int i,int j)
	{
		while(father[i]!=i)
		{
			i = father[i];
		}
		while(father[j]!=j)
		{
			j = father[j];
		}
		father[j] = i;
	}
	void Kruskal()
	{

		int k = 0;
		int n = numVertices;
		EdgeNode *reminfo = new EdgeNode[(n*(n-1))/2];
		for(int i=0;i<numVertices;++i)
		{
			for(int j=i;j<numVertices;++j)
			{
				if(Edge[i][j]!=0)
				{
					reminfo[k].x = i;
					reminfo[k].y = j;
					reminfo[k].weight = Edge[i][j];
					k++;
				}
					
			}
		}
		/用一个结构体数组将有权的边存起来。
		qsort(reminfo,k,sizeof(EdgeNode),compare);
		int *father = new int[k];//这个是核心！！！
		for(int i=0;i<k;i++)
		{
			father[i] = i;
		}
		int v1,v2;
		for(int i=0;i<k;++i)
		{
			if(!Is_Same(father,reminfo[i].x,reminfo[i].y))
			{
				v1 = reminfo[i].x;
			    v2 = reminfo[i].y;
			    cout<<i<<':'<<VerticesList[v1]<<"-->"<<VerticesList[v2]<<':'<<reminfo[i].weight<<endl;
				Mark_Same(father,v1,v2);
			}
		}
	}
};
//注意这个函数必须写到外面。
int compare(const void* w1,const void* w2)
{
	return ((*(EdgeNode*)w1).weight - (*(EdgeNode*)w2).weight);
}

主函数：

#include"grap.h"
int main()
{
	Grap<char,int> gp1;
	cout<<"======================================"<<endl;
	gp1.InsertVertices('A');
	gp1.InsertVertices('B');
	gp1.InsertVertices('C');
	gp1.InsertVertices('D');
	gp1.InsertVertices('E');
	gp1.InsertVertices('F');
	gp1.InsertEdge('A','B',6);
    gp1.InsertEdge('A','C',1);
	gp1.InsertEdge('A','D',5);
	gp1.InsertEdge('B','C',5);
	gp1.InsertEdge('D','C',5);
	gp1.InsertEdge('E','C',6);
	gp1.InsertEdge('F','C',4);
	gp1.InsertEdge('B','E',3);
	gp1.InsertEdge('E','F',6);
	gp1.InsertEdge('D','F',2);
	gp1.ShowGrap();
	cout<<"-------------------------------"<<endl;
	gp1.Kruskal();
	return 0;
}

（2）普利姆算法（Prim）

从指定的一个点开始，链接权值最小的边，两个顶点合并遍历所有点，找权值最小的边，再相连，在合并（这个过程中不可以连上形成回路的边）......直到所有点都连完了。

核心操作是：增加两个数组：lowcost[i]和mst[i]
#pragma once
#include"AllHead.h"
#define MAXSIZE 10 
#define MAX_COST 0x7FFFFFFF
template<class T,class E>
class Grap
{
private:
	T *VerticesList;  //顶点元素
	E **Edge;         //动态的二维数组
	int maxVertices;  //预定最多的顶点个数
	int numVertices;  //记录元素的个数
	int numEdge;      //记录边的个数
public:
	Grap(int sz = 0):maxVertices(sz>MAXSIZE?sz:MAXSIZE),numVertices(0),numEdge(0)
	{
		int i,j;
		Edge = new E*[maxVertices];
		for(i = 0;i<maxVertices;++i)
		{
			Edge[i] = new E[maxVertices];
		}
		VerticesList = new T[maxVertices];
		for(i=0;i<maxVertices;++i)
		{
			VerticesList[i] = '#';
		}
		for(i = 0;i<maxVertices;i++)
		{
			for(j = 0;j<maxVertices;++j)
				Edge[i][j] = MAX_COST;
		}
		for(i = 0;i<maxVertices;++i)
		{
			for(j = 0;j<maxVertices;++j)
			{
				if(i == j)
				{
					Edge[i][j] = 0;
				}
			}

		}
	}
	Grap(T ar[],int sz):maxVertices(sz),numVertices(sz),numEdge(0)
	{
		int i,j;
		Edge = new E*[maxVertices];
		for(i = 0;i<maxVertices;++i)
		{
			Edge[i] = new E[maxVertices];
		}
		VerticesList = new T[maxVertices];
		for(i=0;i<maxVertices;++i)
		{
			VerticesList[i] = ar[i];
		}
		for(i = 0;i<maxVertices;i++)
		{
			for(j = 0;j<maxVertices;++j)
				Edge[i][j] = 0;
		}
	}
public:
	int GetVerticespos(T x)
	{
		int i;
		for(i = 0;i<numVertices;++i)
		{
			if(VerticesList[i] == x)
				return i;
		}
		return -1;
	}
	int NumberOfVertices()
	{return numVertices;}
	int NumberOfEdge()
	{return numEdge;}
public:
	int RemoveEdge(T x1,T x2)
	{
		int v1 = GetVerticespos(x1);
		int v2 = GetVerticespos(x2);
		if(v1 == -1||v2 == -1)
			return -1;
		Edge[v1][v2] = 0;
		Edge[v2][v1] = 0;
		--numEdge;
		return OK;
	}
	int RemoveVertex(T x)
	{
		int v = GetVerticespos(x);
		if(v == -1)
		{
			cout<<"结点不存在..."<<endl;
			return ERROR;
		}
		int i,j,tempedge = 0;
		for(int i=0; i<numVertices; ++i)
		{
			if(Edge[v][i] != 0)
				tempedge++;
		}
		VerticesList[v] = VerticesList[numVertices - 1];
		for(i = 0;i<numVertices;++i)
		{
			Edge[v][i] = Edge[numVertices - 1][i];
		}
		for(j = 0;j<numVertices;++j)
		{
			Edge[j][v] = Edge[j][numVertices - 1];
		}
		--numVertices;
		numEdge -= tempedge; 
	}
	int GetNextNeighbor(T x1,T x2)
	{
		int i;
		int v1 = GetVerticespos(x1);//头 
		int v2 = GetVerticespos(x2);//第一个子
		if(v1 == -1||v2 == -1)
		{
			cout<<"有个顶点不存在...";
			return ERROR;
		}
		if(Edge[v1][v2] == 0)
		{
			cout<<"第一条线并不存在....";
			return ERROR;
		}
		for(i = v2+1;i<numVertices;++i)
		{
			if(Edge[v1][i] == 1)
				return i;
		}
		cout<<"没有下一个顶点....";
		return -1;
	}
	int GetFirstNeighbor(T x)
	{
		int i;
		int v = GetVerticespos(x);
		if(v == -1)
		{
			cout<<"没有这个结点..."<<endl;
		}
		else
		{
			for(i=0;i<numVertices;++i)
			{
				if(Edge[v][i] == 1)
					return i;
			}
		}
		return -1;
	}
	int GetWeight(int v1,int v2)
	{
		if(v1 == -1||v2 == -1)
			return MAX_COST;
		return Edge[v1][v2];
	}
	int InsertEdge(T x1,T x2,int weight)
	{
		int v1 = GetVerticespos(x1);
		int v2 = GetVerticespos(x2);
		if(v1 != -1&&v2 != -1)
		{
			Edge[v1][v2] = weight;
			Edge[v2][v1] = weight;
			++numEdge;
			return OK;
		}
		else
			return ERROR;
	}
	int InsertVertices(T x)
	{
		if(numVertices >= maxVertices)
		{
			cout<<"空间已满(Insert)........"<<endl;
			return ERROR; 
		}
		VerticesList[numVertices++] = x;
		return OK;
	}
	void ShowGrap()
	{
		int i,j;
		cout<<"   ";
		for(i=0;i<numVertices;++i)
		{
			cout<<VerticesList[i]<<"  ";
		}
		cout<<endl;
		for(i = 0;i<numVertices;i++)
		{
			cout<<VerticesList[i]<<"  ";
			for(j = 0;j<numVertices;++j)
			{
				if(Edge[i][j] == MAX_COST)
				{
					cout<<"@  ";
				}
				else
				{
				    cout<<Edge[i][j]<<"  ";
				}
			}
			cout<<endl;
		}
	}
	void Prim(T x)
	{
		int begin,end;
		E cost;
		int n = numVertices;
		E *lowcost = new E[n];
		int *mst = new int[n];
		assert(lowcost != NULL&&mst != NULL);
		int k = GetVerticespos(x);
		for(int i=0;i<n;++i)
		{
			if(i != k)
			{
				lowcost[i] = GetWeight(k,i);//把起始点的权逐个放到lowcost的数组里
				mst[i] = k;
			}
			else
			{
				lowcost[i] = 0;
			}
		}
		for(int i=0;i<n-1;++i)
		{
			int min = MAX_COST;//记录上次一x为顶点的边的权值
			int min_index = -1;//记录上次一x为顶点的边的终点索引号
			for(int j=0;j<n;++j)
			{
				if(lowcost[j]!=0 && lowcost[j]<min)
				{
					min = lowcost[j];
					min_index = j;
				}
			}
			//打印信息；
			begin = mst[min_index];
			end = min_index;
			cout<<VerticesList[begin]<<"--->"<<VerticesList[end]<<':'<<min<<endl;
			//合并顶点。
			lowcost[min_index] = 0;
			for(int j = 0;j<n;++j)
			{
				cost = GetWeight(min_index,j);
				if(cost < lowcost[j])
				{
					lowcost[j] = cost;
					mst[j] = min_index;
				}
			}
		}
		delete[]lowcost;
		delete[] mst;
	}

};

主函数：

#include"MinSpanTree.h"
int main()
{
	Grap<char,int> MinST;
	MinST.InsertVertices('A');
	MinST.InsertVertices('B');
	MinST.InsertVertices('C');
	MinST.InsertVertices('D');
	MinST.InsertVertices('E');
	MinST.InsertVertices('F');
	MinST.InsertEdge('A','B',6);
	MinST.InsertEdge('A','C',1);
	MinST.InsertEdge('A','D',5);
	MinST.InsertEdge('C','B',5);
	MinST.InsertEdge('E','B',3);
        MinST.InsertEdge('C','E',6);
	MinST.InsertEdge('C','F',4);
	MinST.InsertEdge('D','F',2);
	MinST.InsertEdge('C','D',5);
	MinST.InsertEdge('E','F',6);
	MinST.ShowGrap();
	MinST.Prim('A');
	return 0;
}



小小小青菜
关注
专栏目录
Prim与Kruskal算法的最小生成树matlab实现
05-26
在通信网理论作业3-最小生成树这个项目中，你可能会学习如何用MATLAB编写代码，实现Prim和Kruskal算法，并对给定的网络图数据进行最小生成树的构造。这将涉及到数据结构的设计、图的遍历以及最小生成树的验证等编程...
【图】（四）最小生成树详解 - Prim与Kruskal - C语言
友人帐_的博客
11-03 1259
详细地介绍了最小生成树问题的概念、求解思想。并给出求解问题的Prim算法与Kruskal算法的实现。
实验五 图的物理实现（邻接表）
悲伤无声地涌出来
11-29 796
​​​​​​2018-12-4更新 增添了memset函数对标记数组mark重置 --------------------------------------------------------------------------------------------------------------------------------------------------- 说明 基于邻接...
（c++）数据结构与算法之图：邻接矩阵、深度广度遍历、构造最小生成树（prim、kruskal算法）
CSDNMARKT的博客
12-18 1410
//图的邻接矩阵实现 //广度遍历bfs和深度遍历dfs //构造最小生成树的prim、kruskal算法 #include #include #include #define WEIGHTMAX 100 #define VERTEXMAX 50 #define VISITED 1 #define UNVISITED 0 using namespace std; class ufset
图的应用，最小生成树，Prim、Kruskal算法详解及C++代码详细实现
weixin_45651616的博客
07-27 992
图的应用，最小生成树，Prim、Kruskal算法构造最小生成树详细过程及C++代码详细实现
数据结构C++——最小生成树之Prim算法和Kruskal算法
qq_54162207的博客
06-04 5833
数据结构C++——最小生成树之Prim算法和Kruskal算法 文章目录数据结构C++——最小生成树之Prim算法和Kruskal算法一、最小生成树的基本概念二、最小生成树之Prim算法①Prim算法的实现原理②Prim算法中的Min函数的实现③Prim算法的代码实现④测试的完整代码三、最小生成树之Kruskal算法①Kruskal算法的实现原理②Krusal算法的代码实现③测试的完整代码四、总结 一、最小生成树的基本概念 最小生成树： 在一个连通网的所有生成树中，各边的代价之和最小的那棵生成树称为该连通网
python最小生成树kruskal与prim算法详解
12-24
在Python中，有多种实现最小生成树的方法，其中最著名的两种是Kruskal算法和Prim算法。 **Kruskal算法**的主要思想是基于并查集（Disjoint Set）数据结构来避免形成环路。首先，将所有边按照权重从小到大排序。然后...
C++使用Kruskal和Prim算法实现最小生成树
12-31
很久以前就学过最小生成树之Kruskal和Prim算法，这两个算法很容易理解，但实现起来并不那么容易。最近学习了并查集算法，得知并查集可以用于实现上述两个算法后，我自己动手实现了最小生成树算法。 宏观上讲，...
cpp-图论算法最小生成树Prim算法和Kruskal算法C实现
08-16
本文将详细介绍两种经典算法来解决最小生成树问题：Prim算法和Kruskal算法，并以C语言实现为例进行讲解。 ### Prim算法 Prim算法是一种贪心算法，其基本思想是从一个初始节点开始，逐步添加最短的边，直到连接到...
知识点四 图论：Prim算法 Kruskal算法 （最小生成树）
Authur_gyc
07-17 926
解决的问题 这两个算法都是用来在加权连通图里搜索最小生成树。 也就是一个图有很多边，这些边有权值，然后我们要从这些边中找到这样一个边的集合，使得全部的顶点都是连通的，并且边的权值之和最小。 Prim(普里姆算法) 算法描述： 1).输入：一个加权连通图，其中顶点集合为V，边集合为E； 2).初始化：Vnew = {x}，其中x为集合V中的任一节点（起始点），Enew = {},为空； 3).重复下...
prim算法_C语言实现常用数据结构：最小生成树之Kruskal算法（第20篇）
weixin_39793708的博客
10-21 176
「今天是学习C语言第 163 天」纸上学来终觉浅，绝知此事要躬行。——陆游「冬夜读书示子聿」# 最小生成树对于一个n个顶点的连通图，可以选择n-1条边构成生成树，树中的代价等于n-1条边的和，因此最小生成树是图生成的代价最小的生成树。求解最小生成树算法主要有两种，分别是Prim算法和Kruskal算法。下一篇学习Prim算法。# Kruskal算法基本思想对n个顶点构成的连通图中所有的...
最小生成树的Prim算法以及Kruskal算法（C语言）
派拉斯兔子的博客
08-06 1229
一、生成树 连通图的生成树是包含图中全部顶点的一个极小连通子图。 边尽可能的少，但要保持连通 若图中顶点数为n，则它的生成树含有 n-1 条边。对生成树而言，若砍去它的一条边，则会变成非连通图，若加上一条边则会形成一个回路。 （一）最小生成树（最小代价树） 对于⼀个带权连通⽆向图G = (V, E)，⽣成树不同，每棵树的权（即树中所有边上的权值之和）也可能不同。设R为G的所有⽣成树的集合，若T为R中边的权值之和最⼩的⽣成树，则T称为G的最⼩⽣成树（Minimum-Spanning-Tree，MST）
C++ 图进阶系列之 kruskal 和 Prim 算法_图向最小生成树的华丽转身
最新发布
y6123236的专栏
01-31 682
树和图形状相似，也有差异性。树中添加一条或多条边，可成图。图中减小一条或多条边，可成树。形态的变化由数据之间的逻辑关系决定。图用来描述数据之间多对多关系。树用来描述数据之间一对多关系。思考如下问题？需求通过每一个街区。线路或造价等最短（少）。街区之间的逻辑关系可以用无向加权图描述。建设地铁，意味着在图中查找一棵最小生成树，这样才能满足上述要求。什么是最小生成树？包含图中的所有顶点。树中不能有环（每个顶点仅能出现一次）。树中所有边的权重之和最小。如果一个算法能同时解决上面的3。
公路村村通 (30分)【C语言】Prim算法 和 Kruskal算法
Try_again_once的博客
07-05 2328
目录题目：输入格式输出格式输入样例输出样例问题分析最小生成树的特点算法Prim算法代码实现Prim函数：小树变大的过程中记录fee(费用和）和count（已收集的边数）FindMinDistVertex函数：寻找距collected集合最近的结点其他函数：邻接矩阵基础操作方法二代码实现子函数：说明子函数：说明子函数：说明方法三代码实现子函数：说明子函数：说明子函数：说明 习题讲解视频 题目： 现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本
算法（图论）——最小生成树及其题目应用（prim和Kruskal算法实现）
Think Different.
11-16 212
题目 n个村庄间架设通信线路，每个村庄间的距离不同，如何架设最节省开销？ Kruskal算法 特点 适用于稀疏图，时间复杂度 是nlogn的。 核心思想 从小到大选取不会产生环的边。 代码实现 代码中需要采用并查集的方法检测是否有环。 class Edge { int a, b, val; public Edge(int a, int b, int val) { this.a = a; this.b = b; this.val = val; } } int[] father;
数据结构与C语言实现（十一）——图（下）：最小生成树与Prim与Kruskal算法
Sonihr的犀牛园
10-24 524
1.Prim算法，来自于Dijkstra算法的变化，选取一个起始点，然后每次寻找距离这个点权值最小的点，收入树中（使它距离源点的距离为0），然后整个树相当于都是源点，而在V集合中（V集合指的是不在S集合中的点，也就是说还没被收录到树中的点）找一个权值最小的，然后收录之，依次循环，直到所有的点都被收录。 这是一种从点出发的算法，在Dijkstra算法上进行改进。 注意到，我们的初始化过程中首先将
【图的应用-最小生成树-MST性质-普里姆算法（Prim）-克鲁斯卡尔算法（Kruskal）-比较】
weixin_43476632的博客
03-27 148
prim算法：利用已经在树里的顶点集合U和未在树里的集合V-U，找到他们之间代价最小的边； （1）初始是随机选择一个顶点加入 克鲁斯卡尔算法：与prim不同，克鲁斯卡尔初始时将所有的顶点都加到树里面，让边的权值从小到大排序，依次选择最小的边加入到树里，如果加入的边形成了环就不加，选择下一个边；直到树里边的边为n-1个 比较： ...
C语言无向图最小生成树Prim普利姆算法
gzdvdsadf的博客
09-14 2951
代码为对Prim算法实现定义的直观构造
邻接表的深度遍历 c语言 数据结构 简单易懂 超详细~~
weixin_54907221的博客
11-24 1233
#include<stdio.h> #include<stdlib.h> #define maxsize 100 int visited[maxsize];//结点是否被访问的标志信息 typedef struct edgenode//建立边表结点 { int adjvex;//存储相邻节点的下标 edgenode* next;//指向下一个结点的指针 }edgenode; typedef struct vertexnode//建立顶点表 { //顶点表可以用数组，也可以用链表 //
最小生成树Kruskal和Prim算法详解及实例分析
总的来说，最小生成树问题是图论中一个重要且应用广泛的问题，算法中的Kruskal算法和Prim算法是解决这个问题的两种主要方法。通过应用这两种算法，我们可以有效地解决类似离散城镇互通问题的实际应用场景，从而优化...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值