《数据结构（C语言版）第二版》第六章-图（6.6 图的应用——6.6.1 最小生成树）

已于 2024-08-20 16:53:56 修改
阅读量67 收藏
点赞数 1
分类专栏： 《数据结构（C语言版）第二版》 文章标签： 数据结构 算法 c语言 c语言版 开发语言
于 2024-08-18 01:39:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44883214/article/details/141289953
版权

6.6.1.1普里姆算法（稠密网）

#include <stdio.h>
#include <stdlib.h>

#define MaxInt 32767  
//此程序中，将无向网中的权值初始化了为0.因此最终不存在的边其权值为0，而非MaxInt

#define MVNum 100

typedef char VerTexType;
typedef int ArcType;

typedef struct AMGraph
{
	VerTexType vexs[MVNum];
	ArcType arcs[MVNum][MVNum];
	int vexnum;
	int arcnum;
}AMGraph;


typedef struct V_UVexNode
{
	VerTexType adjvex;
	ArcType lowcost;
}V_UVexNode;

V_UVexNode closedge[MVNum];  //此声明数组中前面不能加typedef

void CreateAMGraph(AMGraph& G);
int LocateVex(AMGraph G, VerTexType e);
void printAMGraph(AMGraph G);
void MiniSpanTree_Prim(AMGraph G, VerTexType u);
int Min(AMGraph G, V_UVexNode closedge[]);


int main()
{
	AMGraph G = { {0},{0},0,0 };
	int i = 0;

	CreateAMGraph(G);
	printAMGraph(G);

	printf("\n");

	for (i = 0; i < G.vexnum; i++)
	{
		printf("\n从第%d个顶点%c出发，构造采用邻接矩阵表示的图G的最小生成树T：", i + 1, G.vexs[i]);
		MiniSpanTree_Prim(G, G.vexs[i]);
	}

	return 0;
}

//构造邻接矩阵
void CreateAMGraph(AMGraph& G)
{
	printf("请输入总顶点数：");
	scanf_s(" %d", &G.vexnum);

	printf("请输入总边数：");
	scanf_s(" %d", &G.arcnum);

	int i = 0;
	int j = 0;
	int k = 0;
	VerTexType v1 = '\0';
	VerTexType v2 = '\0';
	ArcType w = 0;

	for (i = 0; i < G.vexnum; i++)
	{
		printf("请输入第%d个顶点的值：", i + 1);
		scanf_s(" %c", &G.vexs[i], sizeof(VerTexType));

		for (j = 0; j < G.vexnum; j++)
		{
			G.arcs[i][j] = 0;
		}
	}

	for (k = 0; k < G.arcnum; k++)
	{
		printf("请输入第%d条边的两个顶点：", k + 1);
		scanf_s(" %c %c", &v1, sizeof(VerTexType), &v2, sizeof(VerTexType));
		printf("请输入第%d条边的权重：", k + 1);
		scanf_s(" %d", &w, sizeof(ArcType));

		i = LocateVex(G, v1);
		j = LocateVex(G, v2);

		G.arcs[i][j] = w;
		G.arcs[j][i] = G.arcs[i][j];
	}
}


int LocateVex(AMGraph G, VerTexType e)
{
	int i = 0;
	for (i = 0; i < G.vexnum && G.vexs[i] != e; i++)
	{
		;
	}

	return i;
}

void printAMGraph(AMGraph G)
{
	int i = 0;
	int j = 0;

	printf("\n各顶点为：");
	for (i = 0; i < G.vexnum; i++)
	{
		printf("%c ", G.vexs[i]);
	}

	printf("\n邻接矩阵为：\n");
	for (i = 0; i < G.vexnum; i++)
	{
		for (j = 0; j < G.vexnum; j++)
		{
			if (G.arcs[i][j] == 0)
			{
				printf("%d   ", G.arcs[i][j]);
			}
			else
			{
				printf("%d   ", G.arcs[i][j]);
			}
		}
		printf("\n");
	}
}


//无向网G以邻接矩阵形式存储，从顶点u出发构造G的最小生成树T, 输出T的各条边
void MiniSpanTree_Prim(AMGraph G, VerTexType u)
{
	int k = 0;
	int i = 0;
	int j = 0;
	VerTexType u0 = '\0';
	VerTexType v0 = '\0';

	k = LocateVex(G, u);

	for (j = 0; j < G.vexnum; ++j)
	{
		if (j != k && (G.arcs[k][j] != 0)) 
		// G.arcs[k][j] != 0代表各顶点与起始顶点u之间的边存在时，再将其权值存储到closedge数组中
		{
			closedge[j].adjvex = u;
			closedge[j].lowcost = G.arcs[k][j];
		}
		else if (j == k)  //如果是第k+1个顶点，起始顶点u本身，则将其在closedge数组中相应位置的closedge[k].adjvex置为$
		{
			closedge[k].adjvex = '$';
			closedge[k].lowcost = 0;
		}
		else if(G.arcs[k][j] == 0) //如果各顶点Vj+1与第k+1个顶点，起始顶点u之间的边不存在，则将closedge数组中的closedge[j].adjvex置为#
		{
			closedge[j].adjvex = '#';
			closedge[k].lowcost = 0;
		}
	}

	for (i = 1; i < G.vexnum; ++i)
	{
		k = Min(G, closedge);  //closedge数组中各顶点的下标与G.vexs中各顶点的下标是一一对应的
		u0 = closedge[k].adjvex;
		v0 = G.vexs[k];   //closedge数组中各顶点的下标与G.vexs中各顶点的下标是一一对应的

		printf("\n最小生成树T中第%d条边为：(%c, %c)", i, u0, v0);

		closedge[k].adjvex = '$';
		closedge[k].lowcost = 0;

		for (j = 0; j < G.vexnum; ++j)
		{
			if ((G.arcs[k][j] != 0) && (closedge[j].adjvex != '$') && (G.arcs[k][j] < closedge[j].lowcost))
			//Vk+1在顶点集U中（closedge[k].adjvex 为 '$'），Vj+1还在顶点集V-U中时(closedge[j].adjvex != '$')，且(Vk+1,Vj+1)这条边存在(G.arcs[k][j] != 0)， 再将G.arcs[k][j] 和 closedge[j].lowcost相比较
			{
				closedge[j].adjvex = G.vexs[k];
				closedge[j].lowcost = G.arcs[k][j];
			}
			else if ((closedge[j].adjvex == '#') && (G.arcs[k][j] != 0))
			//顶点U中之前所有的顶点都与Vj+1之间不存在边，现在新加入Vk+1与Vj+1之间存在了边，则不用比较权值（closedge[j].lowcost一定为0），直接将将其权值G.arcs[k][j]存入closedge[j].lowcost
			{
				closedge[j].adjvex = G.vexs[k];
				closedge[j].lowcost = G.arcs[k][j];
			}
		}
	}
}

int Min(AMGraph G, V_UVexNode closedge[])
{
	int i = 0;
	int j = 0;
	int k = 0;

	while (closedge[i].lowcost == 0)
	{
		i++;
	}
	//找到V-U中的第一个顶点，跳出

	VerTexType minAdjvex = closedge[i].adjvex;
	ArcType minCost = closedge[i].lowcost;

	j = i;
	/* 谨记此处要记录一下j = i ！！！ 因为如果整个程序，至运行结束一次也不进入for循环中的if语句的话，
	那么此时的closedge[i].lowcost就是closedge数组中最小的权值，也要用j返回 */

	for (k = i + 1; k < G.vexnum; k++)
	{
		if (closedge[k].lowcost != 0 && minCost > closedge[k].lowcost)
		{
			minAdjvex = closedge[k].adjvex;
			minCost = closedge[k].lowcost;
			j = k;
		}
	}

	return j;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

//无向网G以邻接矩阵形式存储，从顶点u出发构造G的最小生成树T, 输出T的各条边
void MiniSpanTree_Prim(AMGraph G, VerTexType u)
{
	int k = 0;
	int i = 0;
	int j = 0;
	VerTexType u0 = '\0';
	VerTexType v0 = '\0';

	printf("\nu = %c", u);
	k = LocateVex(G, u);
	printf("\nk = %d", k);

	for (j = 0; j < G.vexnum; ++j)
	{
		if (j != k && (G.arcs[k][j] != 0)) 
		// G.arcs[k][j] != 0代表各顶点与起始顶点u之间的边存在时，再将其权值存储到closedge数组中
		{
			closedge[j].adjvex = u;
			closedge[j].lowcost = G.arcs[k][j];
		}
		else if (j == k)  //如果是第k+1个顶点，起始顶点u本身，则将其在closedge数组中相应位置的closedge[k].adjvex置为$
		{
			closedge[k].adjvex = '$';
			closedge[k].lowcost = 0;
		}
		else if(G.arcs[k][j] == 0) //如果各顶点Vj+1与第k+1个顶点，起始顶点u之间的边不存在，则将closedge数组中的closedge[j].adjvex置为#
		{
			closedge[j].adjvex = '#';
			closedge[k].lowcost = 0;
		}
	}


	//打印初始化后的closedge数组
	printf("\n\n打印初始化后的closedge数组：");
	for (i = 0; i < G.vexnum; i++)
	{
		printf("\nclosedge[%d].adjvex = %c", i, closedge[i].adjvex);
		printf("，  closedge[%d].lowcost = %d", i, closedge[i].lowcost);
	}


	for (i = 1; i < G.vexnum; ++i)
	{
		k = Min(G, closedge);  //closedge数组中各顶点的下标与G.vexs中各顶点的下标是一一对应的
		printf("\n\n第%d次for循环：k = %d", i, k);

		u0 = closedge[k].adjvex;
		printf("\n第%d次for循环：u0 = %c", i, u0);

		v0 = G.vexs[k];   //closedge数组中各顶点的下标与G.vexs中各顶点的下标是一一对应的
		printf("\n第%d次for循环：v0 = %c", i, v0);

		printf("\n最小生成树T中第%d条边为：(%c, %c)", i, u0, v0);

		closedge[k].adjvex = '$';
		closedge[k].lowcost = 0;
		printf("\n第%d次for循环往U中新加的顶点为： %c", i, G.vexs[k]);

		for (j = 0; j < G.vexnum; ++j)
		{
			if ((G.arcs[k][j] != 0) && (closedge[j].adjvex != '$') && (G.arcs[k][j] < closedge[j].lowcost))
			//Vk+1在顶点集U中（closedge[k].adjvex 为 '$'），Vj+1还在顶点集V-U中时(closedge[j].adjvex != '$')，且(Vk+1,Vj+1)这条边存在(G.arcs[k][j] != 0)， 再将G.arcs[k][j] 和 closedge[j].lowcost相比较
			{
				printf("\n更新的closedge数组的下标为：%d", j);
				closedge[j].adjvex = G.vexs[k];
				closedge[j].lowcost = G.arcs[k][j];

				printf("\nclosedge[%d].adjvex = %c", j, closedge[j].adjvex);
				printf("，  closedge[%d].lowcost = %d", j, closedge[j].lowcost);
			}
			else if ((closedge[j].adjvex == '#') && (G.arcs[k][j] != 0))
			{
				closedge[j].adjvex = G.vexs[k];
				closedge[j].lowcost = G.arcs[k][j];
			}
		}


		printf("\n打印第%d次for循环更新后的closedge数组：", i);
		for (j = 0; j < G.vexnum; j++)  //不能用i作为下标了，退出for循环后，i的值会被延续
		{
			printf("\nclosedge[%d].adjvex = %c", j, closedge[j].adjvex);
			printf("，  closedge[%d].lowcost = %d", j, closedge[j].lowcost);
		}
	}
}

int Min(AMGraph G, V_UVexNode closedge[])
{
	int i = 0;
	int j = 0;
	int k = 0;

	while (closedge[i].lowcost == 0)
	{
		i++;
	}
	//找到V-U中的第一个顶点，跳出

	VerTexType minAdjvex = closedge[i].adjvex;
	ArcType minCost = closedge[i].lowcost;

	j = i;
	/* 谨记此处要记录一下j = i ！！！ 因为如果整个程序，至运行结束一次也不进入for循环中的if语句的话，
	那么此时的closedge[i].lowcost就是closedge数组中最小的权值，也要用j返回 */

	printf("\nminAdjvex = closedge[%d].adjvex = %c", i, closedge[i].adjvex);
	printf("\nminCost = closedge[%d].lowcost = %d", i, closedge[i].lowcost);

	for (k = i + 1; k < G.vexnum; k++)
	{
		printf("\nk = %d", k);

		if (closedge[k].lowcost != 0 && minCost > closedge[k].lowcost)
		{
			minAdjvex = closedge[k].adjvex;
			minCost = closedge[k].lowcost;
			printf("\nif条件中：k = %d", k);
			j = k;
			printf("\nif条件中：j = %d", j);
		}
	}

	printf("\nj = %d", j);
	return j;
}

6.6.1.2克鲁斯卡尔算法（稀疏网）

#include <stdio.h>
#include <stdlib.h>

#define MVNum 100
#define MANum 200

typedef char VerTexType;
typedef int ArcType;

typedef struct
{
	VerTexType vexs[MVNum];
	ArcType arcs[MVNum][MVNum];
	int vexnum;
	int arcnum;
}AMGraph;


//辅助数组Edge的定义
typedef struct arc
{
	VerTexType Head;
	VerTexType Tail;
	ArcType lowcost;
}arc;

arc Edge[MANum];

//辅助数组Vexset的定义
int Vexset[MVNum];


void CreateAMGraph(AMGraph& G);
int LocateVex(AMGraph G, VerTexType v);
void printAMGraph(AMGraph G);
void MinSpanTree_Kruskal(AMGraph G);
void Quick_Sort(arc Edge[], int low, int high);

int main()
{
	AMGraph G = { {0},{0},0,0 };

	CreateAMGraph(G);
	printAMGraph(G);
	MinSpanTree_Kruskal(G);

	return 0;
}

void CreateAMGraph(AMGraph& G)
{
	printf("请输入总顶点数：");
	scanf_s(" %d", &G.vexnum);

	printf("请输入总边数：");
	scanf_s(" %d", &G.arcnum);

	int i = 0;
	int j = 0;
	int k = 0;
	VerTexType v1 = '\0';
	VerTexType v2 = '\0';
	ArcType w = 0;

	for (i = 0; i < G.vexnum; i++)
	{
		printf("请输入第%d个顶点的值：", i + 1);
		scanf_s(" %c", &G.vexs[i]);

		for (j = 0; j < G.vexnum; j++)
		{
			G.arcs[i][j] = 0;
		}
	}

	for (k = 0; k < G.arcnum; k++)
	{
		printf("请输入第%d条边依附的两个顶点：", k + 1);
		scanf_s(" %c %c", &v1, sizeof(VerTexType), &v2, sizeof(VerTexType));

		printf("请输入第%d条边的权值：",k+1);
		scanf_s(" %d", &w);

		Edge[k].Head = v1;
		Edge[k].Tail = v2;
		Edge[k].lowcost = w;


		i = LocateVex(G, v1);
		j = LocateVex(G, v2);

		G.arcs[i][j] = w;
		G.arcs[j][i] = G.arcs[i][j];
	}
}


int LocateVex(AMGraph G, VerTexType v)
{
	int i = 0;

	for (i = 0; i < G.vexnum && G.vexs[i] != v; i++)
	{
		;
	}

	return i;
}

void printAMGraph(AMGraph G)
{
	int i = 0;
	int j = 0;

	printf("各顶点为：");
	for (i = 0; i < G.vexnum; i++)
	{
		printf("%c ", G.vexs[i]);
	}

	printf("\n邻接矩阵为：\n");
	for (i = 0; i < G.vexnum; i++)
	{
		for (j = 0; j < G.vexnum; j++)
		{
			printf("%d ", G.arcs[i][j]);
		}

		printf("\n");
	}
}


//无向网G以邻接矩阵形式存储，构造G的最小生成树T, 输出T的各条边
void MinSpanTree_Kruskal(AMGraph G)
{
	int i = 0;
	int j = 0;
	int v1 = '\0';
	int v2 = '\0';
	int vs1 = 0;
	int vs2 = 0;
	int edgeCount = 0; //记录已加入MST的边数

	Quick_Sort(Edge,0,G.arcnum -1);

	/* Vexset数组与G.vexs数组中的下标是一一对应的，即图中被标记序号为第i+1个的顶点Vi,其在G.vexs数组中的下标是i.
	那么在Vexset数组中，下标为i处，存储的就是第i+1个的顶点Vi所在的连通分量的信息。*/
	for (i = 0; i < G.vexnum; i++)
	{
		Vexset[i] = i;
	}
	//每个连通分量用序号来命名。Vexset数组中各下标i处的值i，代表的就是图中第i+1个的顶点Vi所在的连通分量。


	for (i = 0; i < G.arcnum; i++)
	{
		v1 = LocateVex(G, Edge[i].Head);
		v2 = LocateVex(G, Edge[i].Tail);

		vs1 = Vexset[v1];
		vs2 = Vexset[v2];

		if (vs1 != vs2)
		{
			edgeCount++;
			printf("\n最小生成树T中第%d条边为：(%c, %c)，其权值为：%d", edgeCount,Edge[i].Head, Edge[i].Tail,Edge[i].lowcost);

			for (j = 0; j < G.vexnum; ++j)
			{
				if (Vexset[j] == vs2)
				{
					Vexset[j] = vs1;
				}
			}
		}
	}
}

//运用快速排序法
void Quick_Sort(arc Edge[], int low,int high)
{
	int i = low;
	int j = high;
	arc key_arc = Edge[i];
	int key = Edge[i].lowcost;

	while (i < j)
	{
		while (i < j && Edge[j].lowcost >= key)
		{
			j--;
		}
		Edge[i] = Edge[j];

		while (i < j && Edge[i].lowcost <= key)
		{
			i++;
		}
		Edge[j] = Edge[i];
	}

	Edge[i] = key_arc;


	if (i - 1 > low)
	{
		Quick_Sort(Edge, low, i - 1);
	}

	if (i + 1 < high)
	{
		Quick_Sort(Edge, i+1, high);
	}
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

//无向网G以邻接矩阵形式存储，构造G的最小生成树T, 输出T的各条边
void MinSpanTree_Kruskal(AMGraph G)
{
	int i = 0;
	int j = 0;
	int v1 = '\0';
	int v2 = '\0';
	int vs1 = 0;
	int vs2 = 0;
	int edgeCount = 0; //记录已加入MST的边数

	printf("\n排序之前Edge数组中的各边顺序为：");
	for (i = 0; i < G.arcnum; i++)
	{
		printf("\n Edge[%d] ：(%c, %c)，其权值为：%d",i, Edge[i].Head, Edge[i].Tail, Edge[i].lowcost);
	}


	Quick_Sort(Edge,0,G.arcnum -1);

	printf("\n\n排序之后Edge数组中的各边顺序为：");
	for (i = 0; i < G.arcnum; i++)
	{
		printf("\n Edge[%d] ：(%c, %c)，其权值为：%d", i, Edge[i].Head, Edge[i].Tail, Edge[i].lowcost);
	}

	/* Vexset数组与G.vexs数组中的下标是一一对应的，即图中被标记序号为第i+1个的顶点Vi,其在G.vexs数组中的下标是i.
	那么在Vexset数组中，下标为i处，存储的就是第i+1个的顶点Vi所在的连通分量的信息。*/
	for (i = 0; i < G.vexnum; i++)
	{
		Vexset[i] = i;
	}
	//每个连通分量用序号来命名。Vexset数组中各下标i处的值i，代表的就是图中第i+1个的顶点Vi所在的连通分量。

	printf("\n打印初始化后的辅助数组Vexset：");
	for (i = 0; i < G.vexnum; i++)
	{
		printf("\nVexset[%d] = %d", i, Vexset[i]);
	}

	for (i = 0; i < G.arcnum; i++)
	{
		printf("\n\n正在进行判断的边是：(%c, %c)，其权值为：%d", Edge[i].Head, Edge[i].Tail, Edge[i].lowcost);
		v1 = LocateVex(G, Edge[i].Head);
		v2 = LocateVex(G, Edge[i].Tail);

		vs1 = Vexset[v1];
		printf("\n顶点%c所属连通分量的下标为：%d", Edge[i].Head, vs1);

		vs2 = Vexset[v2];
		printf("\n顶点%c所属连通分量的下标为：%d", Edge[i].Tail, vs2);

		if (vs1 != vs2)
		{
			edgeCount++;
			printf("\n最小生成树T中第%d条边为：(%c, %c)，其权值为：%d", edgeCount,Edge[i].Head, Edge[i].Tail,Edge[i].lowcost);

			for (j = 0; j < G.vexnum; ++j)
			{
				if (Vexset[j] == vs2)
				{
					Vexset[j] = vs1;
				}
			}

			printf("\n打印更新后的辅助数组Vexset：");
			for (j = 0; j < G.vexnum; j++)  
			//不能用i做下标值，结束该for循环后，i值还会延续
			{
				printf("\nVexset[%d] = %d", j, Vexset[j]);
			}
		}
	}
}

Flerken101
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《数据结构（C语言版）》综述
NDSCRESU的专栏
04-19 1015
第一章 绪论（将于4月20日学习完毕，含课后题以及资料练习题）1.1什么是数据结构 1.2基本概念和术语 1.3抽象数据结构类型的表示与实现 1.4算法和算法分析 —-1.4.1算法 —-1.4.2算法设计的要求 —-1.4.3算法效率的度量第二章 线性表2.1线性表的类型定义 2.2线性表的顺序表示和实现 2.3线性表的链式表示和实现 —-2.3.
gradle-6.6.1-all.zip 快速下载
10-29
Gradle-6.6.1 此版本最大亮点是引入了一个实验性选项：配置缓存（Configuration caching），它是一个主要的性能优化特性，可以使 Gradle 跳过构建的配置阶段，并尽快开始执行任务。
数据结构C语言严蔚敏版(第二版)超详细笔记附带课后习题
热门推荐
chongyang_的博客
11-07 26万+
根据此书所做随笔笔记。 一、绪论 1.1、数据机构的研究内容 用计算机解决实际问题时，步骤：首先分析实际问题，从中抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编程，调试，测试。 寻求数据模型的实质是分析问题，从中提取出计算机处理的对象，并找出这些对象之间的关系，然后用数学的语言加以描述。 关键：分析问题中所用到的数据是如何组织的，研究数据之间存在什么样的关系。 由于数据必须在计算机中处理，因此不能局限于数据本身的数学问题的研究，还必须考虑数据的物理结构，即数据在计算机中的存储结构。 1.
Python数据结构与算法分析（第二版）
aha_xigua的博客
07-29 1656
对列表进行加长操作，比较不同方法的性能pop性能分析。
小黑子—MySQL数据库：第二章 - 进阶篇
VanWot的博客
06-28 551
黑马MySQL58 - 152
vue dev-tools离线安装包 chrome版本 6.6.1
04-13
Vue dev-tools浏览器扩展的下载，安装方式如下： 打开Chrome浏览器–>选择更多工具–>扩展程序–>打开开发者模式,点击“加载已解压的扩展程序” 如果找不到该方式就看下开启开发者模式再试。
排序（归并排序，非比较排序）
qq_63074244的博客
08-20 547
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的 相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，⽽在排序后的序列中，r[i]仍在r[j]之 前，则称这种排序算法是稳定的；否则称为不稳定的。数据结构结构初阶的排序基本上总结完毕了，这里我学了冒泡，插入，选择，快排，希尔，堆，归并，计数排序，这几种排序在时间复杂度，空间复杂度以及稳定性上各有各的优点。下面我们用一张图进行总结。
【Java & 数据结构】初识二叉树
qq_42150700的博客
08-20 471
树是一种非线性的数据结构, 也就是说它和我们前面学习的顺序表链表之类的不太一样. 那些数据结构要求中间的元素都只有一个前驱和后继, 而树型结构的中间元素则允许有多个后继.例如下面这个就是一个树形结构为什么叫这种结构为树形结构呢?这是因为它的结构长的就像一颗倒过来的树, 最上面是树根, 最下面则是叶子.下面我们看几个例子, 来认识一下树形结构的注意点下面的这个结构, 就不是一个树形结构, 原因是其中间在同一层的节点, 是不可以相连的, 中间的节点只允许和上层节点和下层节点进行连接.
数据结构之树的存储结构
DKPT的博客
08-16 536
孩子链表表示法将树中所有节点存储在一个顺序表中，每个数据元素有两个域：数据域和存放该节点第一个孩子地址的指针域。同时，为树中每个节点构建一个单链表，链表中的节点也有两个域：存放该孩子节点在顺序表中的数组下标和指向下一个孩子的指针。对于完全二叉树，如果父节点的索引是i（假设从0开始计数），那么它的左子节点的索引是2i+1，右子节点的索引是2i+2。数组的第一个元素存储树的根节点。双亲表示法通过采用一维数组来存储树中的节点，其中每个节点被赋予一个结构体类型，包含数据域和父节点位置域（parent域）。
【数据结构入门】二叉树之堆的实现
最新发布
KevinRay_0854的博客
08-20 1074
堆是一种重要的数据结构，常用于解决各种问题，如优先队列、排序算法、图算法等。堆具有很多特性，其中最常见的是最大堆和最小堆。最大堆中，每个节点的值都大于等于其子节点的值，而最小堆则相反，每个节点的值都小于等于其子节点的值。在本文中，我们将详细介绍堆的概念、性质和操作。我们将以一个具体的例子来说明堆的构建和调整过程，并通过图示展示堆的结构。最后，我们还将讨论堆在实际应用中的一些常见用途和算法。通过学习堆，您将能够更好地理解和应用这一重要的数据结构。
数据结构【顺序结构二叉树：堆】（1）
qq_67578580的博客
08-20 607
堆排序时间复杂度计算。
C语言基础（六）
wehpd的博客
08-20 216
一维数组
数据结构day01（数据结构、算法基础知识）
dghbs的博客
08-20 768
数据结构就是数据的逻辑结构存储结构以及操作（类似数据的运算）数据结构的最终目的就是：如何更高效的存储数据算法对特定问题求解步骤的一种描述，它是指令的有限序列，期中每一条指令都表示一个或多个操作。数据结构 + 算法 = 程序。
从零开始学数据结构系列之第四章《拓扑排序代码详解》
铁匠匠匠的博客
08-16 1081
以上就是所有内容，对大家有用的话点个关注！我们拿这张图来进行代码详解。此时图的入度表更新为。此时图的入度表更新为。此时图的入度表更新为。此时图的入度表更新为。
C:每日一题：双指针法的使用
JonlyMay的博客
08-20 811
双指针法的使用
数据结构之红黑树
我要学编程的博客
08-16 1140
红黑树的概念、性质、插入、验证； AVL树和红黑树的比较
数据结构(6_2_3)——十字链表法和多重领接表
m0_65240792的博客
08-20 259
橙色入度，绿色出度 代码示例： 十字链表法性能分析 优点：每一条边只对应一个边结点，没有冗余数据，删除结点或者删除边的时候会方便很多 代码示例： 总结：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值