严蔚敏数据结构Prim算法

已于 2022-05-09 09:26:08 修改
阅读量180 收藏 1
点赞数
文章标签： Prim算法 最小生成树 加权无向图 图论 数据结构
于 2022-05-08 20:09:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laohuchishizi/article/details/124653467
版权 
#include <stdio.h>
#include <string.h>
#define OK 1
#define INFINITY 32767
#define MAX_VERTEX_NUM 30
#define MAXINFOLEN 30
#define ERROR 0
#define OVERFLOW -1
#define MAXVERTEXLEN 30
#define FALSE 0
#define TRUE 1
typedef int Status;
typedef enum { DG, DN, UDG, UDN }GraphKind;
typedef int VRType;
typedef int InfoType;
typedef char* VertexType;
typedef struct ArcCell
{
	VRType adj;
	InfoType* info;
}ArcCell, AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
typedef struct
{
	VertexType vexs[MAX_VERTEX_NUM];
	AdjMatrix arcs;
	int vexnum, arcnum;
	GraphKind kind;
}MGraph;
Status CreatGraph(MGraph* G)
{
	printf("请输入图的类型\n");
	scanf("%d", &(G->kind));
	switch (G->kind)
	{
	case DG:return(CreatDG(G)); break;
	case DN:return(CreatDN(G)); break;
	case UDG:return(CreatUDG(G)); break;
	case UDN:return(CreatUDN(G)); break;
	default: return ERROR;
	}
}
Status CreatDG(MGraph* G)
{
	printf("请依次输入图的总结点数，弧数，以及是弧是否需要额外信息，无额外信息输入0，有额外信息输入1\n");
	int info;
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	printf("请输入%d个顶点的描述\n", G->vexnum);
	for (int i = 0; i < G->vexnum; i++)
	{
		G->vexs[i] = (VertexType)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vexs[i]) exit(OVERFLOW);
		gets(G->vexs[i]);
	}
	for(int i=0;i<G->vexnum;i++)
		for (int j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = 0;
			G->arcs[i][j].info = NULL;
		}
	int tail, head;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	for (int i = 0; i < G->arcnum; i++)
	{
		printf("请输入第%d个顶点关系\n", i + 1);
		printf("请输入它的弧尾顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				tail = j;
				break;
			}
		printf("请输入它的弧头顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				head = j;
				break;
			}
		G->arcs[tail][head].adj = 1;
		if (info)
		{
			G->arcs[tail][head].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[tail][head].info) exit(OVERFLOW);
			printf("请输入其信息\n");
			gets(G->arcs[tail][head].info);
		}
	}
	return OK;
}
Status CreatDN(MGraph* G)
{
	printf("请依次输入图的总结点数，弧数，以及是弧是否需要额外信息，无额外信息输入0，有额外信息输入1\n");
	int info;
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	printf("请输入%d个顶点的描述\n", G->vexnum);
	for (int i = 0; i < G->vexnum; i++)
	{
		G->vexs[i] = (VertexType)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vexs[i]) exit(OVERFLOW);
		gets(G->vexs[i]);
	}
	for (int i = 0; i < G->vexnum; i++)
		for (int j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = INFINITY;
			G->arcs[i][j].info = NULL;
		}
	int tail, head;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	for (int i = 0; i < G->arcnum; i++)
	{
		printf("请输入第%d个顶点关系\n", i + 1);
		printf("请输入它的弧尾顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				tail = j;
				break;
			}
		printf("请输入它的弧头顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				head = j;
				break;
			}
		printf("请输入弧的权值\n");
		scanf("%d", &(G->arcs[tail][head]));
		getchar();
		if (info)
		{
			G->arcs[tail][head].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[tail][head].info) exit(OVERFLOW);
			printf("请输入其信息\n");
			gets(G->arcs[tail][head].info);
		}
	}
	return OK;
}
Status CreatUDG(MGraph* G)
{
	printf("请依次输入图的总结点数，弧数，以及是弧是否需要额外信息，无额外信息输入0，有额外信息输入1\n");
	int info;
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	printf("请输入%d个顶点的描述\n", G->vexnum);
	for (int i = 0; i < G->vexnum; i++)
	{
		G->vexs[i] = (VertexType)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vexs[i]) exit(OVERFLOW);
		gets(G->vexs[i]);
	}
	for (int i = 0; i < G->vexnum; i++)
		for (int j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = 0;
			G->arcs[i][j].info = NULL;
		}
	int vex1, vex2;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	for (int i = 0; i < G->arcnum; i++)
	{
		printf("请输入第%d个顶点关系\n", i + 1);
		printf("请输入它所依附的第一个顶点的顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				vex1 = j;
				break;
			}
		printf("请输入它所依附的第二个顶点的顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				vex2 = j;
				break;
			}
		G->arcs[vex1][vex2].adj = 1;
		G->arcs[vex2][vex1].adj = 1;
		if (info)
		{
			G->arcs[vex1][vex2].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[vex1][vex2].info) exit(OVERFLOW);
			printf("请输入其信息\n");
			gets(G->arcs[vex1][vex2].info);
			G->arcs[vex2][vex1].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[vex2][vex1].info) exit(OVERFLOW);
			strcpy(G->arcs[vex2][vex1].info, G->arcs[vex1][vex2].info);
		}
	}
	return OK;
}
Status CreatUDN(MGraph* G)
{
	printf("请依次输入图的总结点数，弧数，以及是弧是否需要额外信息，无额外信息输入0，有额外信息输入1\n");
	int info;
	scanf("%d%d%d", &(G->vexnum), &(G->arcnum), &info);
	getchar();
	printf("请输入%d个顶点的描述\n", G->vexnum);
	for (int i = 0; i < G->vexnum; i++)
	{
		G->vexs[i] = (VertexType)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!G->vexs[i]) exit(OVERFLOW);
		gets(G->vexs[i]);
	}
	for (int i = 0; i < G->vexnum; i++)
		for (int j = 0; j < G->vexnum; j++)
		{
			G->arcs[i][j].adj = INFINITY;
			G->arcs[i][j].info = NULL;
		}
	int vex1, vex2;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	for (int i = 0; i < G->arcnum; i++)
	{
		printf("请输入第%d个顶点关系\n", i + 1);
		printf("请输入它所依附的第一个顶点的顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				vex1 = j;
				break;
			}
		printf("请输入它所依附的第二个顶点的顶点描述\n");
		gets(ch);
		for (int j = 0; j < G->vexnum; j++)
			if (strcmp(ch, G->vexs[j]) == 0)
			{
				vex2 = j;
				break;
			}
		printf("请输入此弧权值\n");
		scanf("%d", &(G->arcs[vex1][vex2].adj));
		getchar();
		G->arcs[vex2][vex1].adj = G->arcs[vex1][vex2].adj;
		if (info)
		{
			G->arcs[vex1][vex2].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[vex1][vex2].info) exit(OVERFLOW);
			printf("请输入其信息\n");
			gets(G->arcs[vex1][vex2].info);
			G->arcs[vex2][vex1].info = (InfoType*)malloc(sizeof(InfoType) * MAXINFOLEN);
			if (!G->arcs[vex2][vex1].info) exit(OVERFLOW);
			strcpy(G->arcs[vex2][vex1].info, G->arcs[vex1][vex2].info);
		}
	}
	return OK;
}



//孩子兄弟树的数据结构描述
typedef char* TElemType;
typedef struct CSNode
{
	TElemType data;
	struct CSNode* firstchild, * nextsibling;
}CSNode, * CSTree;



//队列函数
typedef CSTree QElemType;
typedef struct QNode
{
	QElemType data;
	struct QNode* next;
}QNode, * QueuePtr;
typedef struct
{
	QueuePtr front, rear;
}LinkQueue;
Status InitQueue(LinkQueue* Q)
{
	Q->front = (QNode*)malloc(sizeof(QNode));
	if (!Q->front) exit(OVERFLOW);
	Q->rear = Q->front;
	return OK;
}
Status EnQueue(LinkQueue* Q, QElemType e)
{
	QNode* p;
	p = (QNode*)malloc(sizeof(QNode));
	if (!p) exit(OVERFLOW);
	p->data = e;
	Q->rear->next = p;
	Q->rear = p;
	p->next = NULL;
	return OK;
}
Status DeQueue(LinkQueue* Q, QElemType* e)
{
	if (Q->front == Q->rear)
		return ERROR;
	*e = Q->front->next->data;
	if (Q->rear == Q->front->next)
		Q->rear = Q->front;
	QNode* p = Q->front->next;
	Q->front->next = p->next;
	free(p);
	return OK;
}
Status QueueEmpty(LinkQueue Q)
{
	if (Q.front == Q.rear)
		return TRUE;
	else
		return FALSE;
}
void PrintQueue(LinkQueue Q)
{
	QNode* p = Q.front->next;
	if (!p)
		printf("空\n");
	else
	{
		while (p)
		{
			printf("%d\t", p->data + 1);
			p = p->next;
		}
		printf("\n");
	}
}



void PrintCSTree_LevelOrder(CSTree T)
{
	printf("孩子兄弟树层序输入为\n");
	LinkQueue* Q;
	Q = (LinkQueue*)malloc(sizeof(LinkQueue));
	if (!Q) exit(OVERFLOW);
	InitQueue(Q);
	EnQueue(Q, T);
	QElemType* p;
	p = (QElemType*)malloc(sizeof(QElemType));
	if (!p) exit(OVERFLOW);
	while (!QueueEmpty(*Q))
	{
		DeQueue(Q, p);
		puts((*p)->data);
		if ((*p)->firstchild)
			EnQueue(Q, (*p)->firstchild);
		if ((*p)->nextsibling)
			EnQueue(Q, (*p)->nextsibling);
	}
}

//栈的数据结构及函数
#define STACK_INIT_SIZE 100
#define STACK_INCREASMENT 10
typedef int SElemType;
typedef struct
{
	SElemType* base, * top;
	int stacksize;
}SqStack;
Status InitStack(SqStack* S)
{
	S->base = (SElemType*)malloc(sizeof(SElemType) * STACK_INIT_SIZE);
	if (!S->base) exit(OVERFLOW);
	S->top = S->base;
	S->stacksize = STACK_INIT_SIZE;
}
Status Push(SqStack* S, SElemType e)
{
	if (S->top - S->base > S->stacksize)
	{
		S->base = (SElemType*)realloc(S->base, sizeof(SElemType) * (S->stacksize + STACK_INCREASMENT));
		if (!S->base) exit(OVERFLOW);
		S->stacksize += STACK_INCREASMENT;
	}
	*(S->top) = e;
	S->top++;
	return OK;
}
Status Pop(SqStack* S, SElemType* e)
{
	if (S->base == S->top)
		return ERROR;
	S->top--;
	*e = *(S->top);
	return OK;
}
Status StackEmpty(SqStack S)
{
	if (S.base == S.top)
		return TRUE;
	else
		return FALSE;
}

void PreOrderTraverse_MinSpanTree(CSTree* T, char* ch, CSTree* p)
{
	SqStack S;
	InitStack(&S);
	CSNode* q = (*T);
	while (q || !StackEmpty(S))
	{
		if (q)
		{
			Push(&S, q);
			if (strcmp(ch, q->data) == 0)
			{
				*p = (CSTree)malloc(sizeof(CSNode));
				if (!(*p)) exit(OVERFLOW);
				*p = q;
				break;
			}
			q = q->firstchild;
		}
		else
		{
			Pop(&S, &q);
			q = q->nextsibling;
		}
	}
}
void MinSpanTree(MGraph G, VertexType u, CSTree* T)
{
	struct
	{
		VertexType adjvex;
		VRType lowcost;
	}closeedge[MAX_VERTEX_NUM];
	int k;
	for (int i = 0; i < G.vexnum; i++)
		if (strcmp(u, G.vexs[i]) == 0)
		{
			k = i;
			break;
		}
	for (int i = 0; i < G.vexnum; i++)
	{
		if (i != k)
		{
			closeedge[i].lowcost = G.arcs[k][i].adj;
			closeedge[i].adjvex = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
			if (!closeedge[i].adjvex) exit(OVERFLOW);
			strcpy(closeedge[i].adjvex, u);
		}
	}
	(*T) = (CSTree)malloc(sizeof(CSNode));
	if (!(*T)) exit(OVERFLOW);
	(*T)->data = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!(*T)->data) exit(OVERFLOW);
	strcpy((*T)->data, u);
	(*T)->firstchild = NULL;
	(*T)->nextsibling = NULL;
	closeedge[k].lowcost = 0;
	closeedge[k].adjvex = NULL;
	int count = 1;
	char* ch;
	ch = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!ch) exit(OVERFLOW);
	CSNode* p;
	while (count < G.vexnum)
	{
		int mincost = INFINITY;
		int min;
		for (int i = 0; i < G.vexnum; i++)
			if (closeedge[i].lowcost && closeedge[i].lowcost < mincost)
			{
				mincost = closeedge[i].lowcost;
				min = i;
			}
		strcpy(ch, closeedge[min].adjvex);
		PreOrderTraverse_MinSpanTree(T, ch, &p);          //在树T中找到与ch相同的节点并返回它的指针
		CSNode* q;
		q = (CSNode*)malloc(sizeof(CSNode));
		if (!q) exit(OVERFLOW);
		q->data = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
		if (!q->data) exit(OVERFLOW);
		strcpy(q->data, G.vexs[min]);
		if (p->firstchild)
		{
			p = p->firstchild;
			while (p->nextsibling)
				p = p->nextsibling;
			p->nextsibling = q;
			q->firstchild = NULL;
			q->nextsibling = NULL;
		}
		else
		{
			p->firstchild = q;
			q->nextsibling = NULL;
			q->firstchild = NULL;
		}
		closeedge[min].lowcost = 0;
		closeedge[min].adjvex = NULL;
		for (int j = 0; j < G.vexnum; j++)
			if (closeedge[j].lowcost && G.arcs[min][j].adj < closeedge[j].lowcost)
			{
				closeedge[j].lowcost = G.arcs[min][j].adj;
				strcpy(closeedge[j].adjvex, G.vexs[min]);
			}
		count++;
	}
}
//Prim算法主函数
int main()
{
	MGraph G;
	CSTree* T;
	T = (CSTree*)malloc(sizeof(CSTree));
	if (!T) exit(OVERFLOW);
	CreatGraph(&G);
	printf("\t");
	for (int i = 0; i < G.vexnum; i++)
		printf("V%d\t", i + 1);
	printf("\n\n");
	for (int i = 0; i < G.vexnum; i++)
	{
		printf("V%d\t", i + 1);
		for (int j = 0; j < G.vexnum; j++)
			printf("%d\t", G.arcs[i][j].adj);
		printf("\n\n\n");
	}
	char* u = (char*)malloc(sizeof(char) * MAXVERTEXLEN);
	if (!u) exit(OVERFLOW);
	strcpy(u, G.vexs[0]);
	MinSpanTree(G, u, T);
	PrintCSTree_LevelOrder(*T);
	return 0;
}

输入：

3
6 10 0
V1
V2
V3
V4
V5
V6
V1
V2
6
V1
V3
1
V1
V4
5
V2
V3
5
V3
V4
5
V2
V5
3
V3
V5
6
V5
V6
6
V3
V6
4
V4
V6
2

原图：

 结果：

哆啦BCD梦
关注
2020-10-10 //严蔚敏《数据结构》 //图的遍历：深度优先搜索（DFS）和广度优先搜索（BFS）
weixin_45888287的博客
10-10 719
//严蔚敏《数据结构》 //图的遍历：深度优先搜索（DFS）和广度优先搜索（BFS） //自学中，加油！ #include<iostream> #include<string> using namespace std; #define InfoType double #define VertexType string const int MaxVertexNum=20; typedef struct Edge { int ivex; InfoType* info;
普里姆(Prim)算法，数据机构，c语言，严蔚敏
12-31
16、输入任意的一个网，用普里姆(Prim)算法构造最小生成树。 ，数据机构，c语言，严蔚敏
严蔚敏数据结构图的深度与广度优先遍历
laohuchishizi的博客
05-08 477
深度广度优先
最小生成树-Prim算法（参考 清华大学 《数据结构》 严蔚敏版）
Jasonchen1224的博客
01-28 274
最小生成树 Prim算法（参考 清华大学 《数据结构》 严蔚敏版）
严蔚敏-图-存储结构-图的遍历
CodePandas
02-10 1549
数据结构学习笔记【第7章 图】 7.1 图的定义和术语 图是一种较线性表和树更为复杂的数据结构。在图形结构中，结点之间的关系是任意的，图中任意两个数据元素之间都可能相关。 在图中的数据元素通常称做顶点(Vertex)，V是顶点的有穷非空集合；VR是两个顶点之间的关系的集合。若<v,w>∈VR<v,w>∈VR<v,w>∈VR，则<v,w><v,...
严蔚敏版《数据结构》代码实现
01-13
严蔚敏版的《数据结构》是一本经典的教材，涵盖了广泛的数据结构类型和算法。这里提到的代码实现是基于C++语言，实现了书中讲解的多种数据结构和算法。 1. **线性表**：线性表是一种基本的数据结构，由n（n>=0）个...
数据结构算法实现严蔚敏教材
04-13
图算法如Dijkstra算法、Floyd算法用于找到最短路径，Kruskal和Prim算法用于构造最小生成树。 在C++中实现这些数据结构和算法时，可以利用面向对象的特性，定义类来封装数据和操作，同时利用STL（Standard Template ...
《数据结构》算法源码及运行演示
01-20
例如，Prim算法和Kruskal算法用于最小生成树问题。 13. **图论算法**：包括Dijkstra算法（单源最短路径）、Floyd-Warshall算法（所有顶点间的最短路径）和Ford-Fulkerson方法（最大流问题）。 这个压缩包中的源...
数据结构与算法c语言 严蔚敏 代码实现
06-04
《数据结构与算法C语言》是计算机科学领域中的一本经典教材，由严蔚敏教授编写。这本书深入浅出地介绍了数据结构的基本概念、设计方法和C语言的实现技巧，对于学习计算机科学的学生和程序员来说，是提升算法思维和...
数据结构算法实现（严蔚敏版配套实现程序）
最新发布
08-29
严蔚敏教授的《数据结构》一书，是许多计算机专业学生和程序员学习数据结构的首选教材。这本书以其清晰的理论阐述和丰富的实例，帮助读者深入理解各种数据结构及其算法。 这个压缩包文件包含了严蔚敏版《数据结构》...
Prim算法（数据结构）
12-17
最小生成树是数据结构中图的一种重要应用，它的要求是从一个带权无向完全图中选择n－1条边并使这个图仍然连通（也即得到了一棵生成树）,同时还要考虑使树的权最小。 为了得到最小生成树，人们设计了很多算法，最著名的有prim算法和kruskal算法。
图的深度优先遍历（c语言）
12-29
图的深度优先遍历c语言版 受益良多 可参考数据结构|（清华版 主编 严蔚敏）
Prim 算法的实现
qq_31805127的博客
06-03 1272
最小生成树除了prim还有kruskal算法。Prim算法的实现，用到了优先队列。仅供参考的c++代码：#include &lt;iostream&gt; #include &lt;string&gt; #include &lt;stack&gt; #include &lt;fstream&gt; #include &lt;sstream&gt; #include &lt;ctime&gt; #i...
数据结构：prim算法
theLostLamb的博客
03-05 461
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define inf 999999 bool visit[6] = {false}; int dist[6] = {0}; int graph[6][6] = { {inf, 7, 4, inf, inf, inf}, {7, inf, 6, 2, inf, 4}, {...
数据结构——Prim算法
一个巨大的博客
11-29 4041
Prim算法（加点法） Prim为求图最小生成树的算法 本文章采用邻接矩阵的存储方式 具体思路如下 1.首先以邻接矩阵方式输入图 2.进入算法函数 3.设置closedge数组辅助 typedef struct{ int adjvex; /记录该顶点和顶点集合中相连权值最小的顶点序号/ int lowcost; /记录最小的权值/ }Closedge; //数组元素的下标对应图G...
2020-10-14 //严蔚敏《数据结构》 //最小生成树--Prim算法
weixin_45888287的博客
10-14 683
//严蔚敏《数据结构》 //最小生成树--Prim算法 //自学中，加油！ #include<iostream> #include<string> using namespace std; const int MaxVertexnum=20; const int Infinity=INT_MAX; #define InfoType string #define VRType double #define VertexType string typedef enum{DG,DN,UDG
2021-11-23【数据结构/严蔚敏】【最小生成树：普里姆( Prim )算法/克鲁斯卡尔( Kruskal )算法】【代码实现算法7.7-7.8】
eternity_memory的博客
11-23 1920
最小生成树 假设要在 n 个城市之间建立通信联络网,则连通 n 个城市只需要 n —1条线路。这时,自然会考虑这样一个问题,如何在最节省经费的前提下建立这个通信网。 在每两个城市之间都可以设置一条线路,相应地都要付出一定的经济代价。 n 个城市之间,最多可能设置 n ( n —1)/2条线路,那么,如何在这些可能的线路中选择 n —1条,以使总的耗费最少呢? 可以用连通网来表示 n 个城市以及 n 个城市间可能设置的通信线路,其中网的顶点表示城市,边表示两城市之间的线路,赋于边的权值表示相应的代价。对于 n
数据结构与最小生成树算法
《数据结构(C语言版)》（严蔚敏，吴伟民 编著，清华大学出版社）是一本经典教材，它详细介绍了各种数据结构和相关算法，包括构建最小生成树的方法。此外，还有其他参考书籍如《数据结构与算法分析》等，可以帮助深入...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值