[数据结构]第七章-图(读书笔记1)

最新推荐文章于 2023-07-15 10:22:00 发布
最新推荐文章于 2023-07-15 10:22:00 发布
阅读量1.5k 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Last_Impression/article/details/12350729
版权

第七章--图

图(Graph)是一种较线性表和树更为复杂的数据结构。对于无向图，e的取值范围是0到1/2n(n-1)，有1/2n(n-1)条边的无向图称为完全图(Completed graph)。有很少的边或弧的图称为稀疏图(Sparse graph)。反之称为稠密图(Dense graph)。
有时图的边或弧具有与它相关的数，这种与图的边或弧相关的数叫做权(Weight)。这些权可以表示从一个顶点到另一个顶点的距离或耗费。这种带权的图通常称为网(Network)。

7.2 图的存储结构
图的存储结构有数组表示法和邻接表法。数组表示法是用两个数组分别存储数据元素(顶点)的信息和数据元素之间的关系(边或弧)的信息。

#define INFINITY INT_MAX	/* 用整型最大值代替∞ */
#define MAX_VERTEX_NUM 20  /* 最大顶点个数 */
#define MAX_NAME 20
#define MAX_INFO 20

typedef enum{
	DG,
	DN,
	AG,
	AN
}GraphKind; /* {有向图,有向网,无向图,无向网} */

typedef int VRType;
typedef char InfoType;
typedef char VertexType[MAX_NAME];
typedef struct ArcCell{
	VRType	adj;		/*VRType是顶点关系类型。对无权图用1或0来表示是否相邻*/
	                    /*对于有权图，则为权值类型*/
	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;

int LocateVex(MGraph G,VertexType u)
{	/* 初始条件:图G存在,u和G中顶点有相同特征 */
	/* 操作结果:若G中存在顶点u,则返回该顶点在图中位置;否则返回-1 */
	int i;
	for(i = 0; i <= G.vexnum; i++){
		if ( strcmp(u, G.vexs[i]) == 0 ){
			return i;
		}
	}
	return 0;
}

Status CreateFAG(MGraph *G)
{	/* 采用数组(邻接矩阵)表示法,由文件构造没有相关信息的无向图G */
	int i,j,k;
	char filename[13];
	VertexType va,vb;
	FILE *graphlist;

	printf("请输入数据文件名(f7-1.dat):");
	scanf("%s",filename);
	graphlist = fopen(filename, "r");
	/*输入顶点数*/
	fscanf(graphlist,"%d",&(*G).vexnum);
	/*输入弧数*/
	fscanf(graphlist,"%d",&(*G).arcnum);
	for(i=0;i < (*G).vexnum; i++){/* 构造顶点向量 */
		fscanf(graphlist, "%s", (*G).vexs[i]);
	}
	for(i=0;i < (*G).arcnum; i++){/* 构造邻接矩阵 */
		for(j=0; j < (*G).vexnum; ++j){
			(*G).arcs[i][j].adj = 0; /*图*/
			(*G).arcs[i][j].info = NULL; /*没有相关信息*/
		}
	}
	for(k = 0; k < (*G).arcnum; k++){
		fscanf(graphlist, "%s,%s",va,vb);
		i = LocateVex(*G,va);
		j = LocateVex(*G,vb);
		(*G).arcs[i][j].adj = (*G).arcs[j][i].adj = 1;/*无向图*/
	}
	fclose(graphlist);
	(*G).kind = AG;
	return OK;
}

Status CreateDG(MGraph *G)
{	/* 采用数组(邻接矩阵)表示法,构造有向图G */
	int i,j,k,l,IncInfo;
	char s[MAX_INFO],*info;
	VertexType va,vb;

	printf("请输入有向图G的定点数，弧数，弧是否含其它信息(是1，否0)");
	scanf("%d,%d,%d",&(*G).vexnum, &(*G).arcnum, &IncInfo);
	printf("请输入%d个顶点的值(<%d个字符):\n",(*G).vexnum, MAX_INFO);
	for (i = 0; i < (*G).vexnum; ++i){
		scanf("%s",(*G).vexs[i]);
	}
	for(i = 0 ; i < (*G).vexnum; ++i){ /* 初始化邻接矩阵 */
		for(j = 0; j < (*G).vexnum; ++j){
			(*G).arcs[i][j].adj = 0; /* 图 */
			(*G).arcs[i][j].info = NULL;
		}
	}
	printf("请输入%d条弧的弧尾 弧头(以空格作为间隔): \n",(*G).arcnum);
	for(k=0; k<(*G).arcnum; ++k){
		scanf("%s%s%*c",va,vb);  /* %*c吃掉回车符 */
		i = LocateVex(*G,va);
		j = LocateVex(*G,vb);
		(*G).arcs[i][j].adj = 1; /* 有向图 */
		if(IncInfo){
			printf("请输入该弧的相关信息(<%d个字符): ",MAX_INFO);
			gets(s);
			l=strlen(s);
			if(l){
				info=(char*)malloc((l+1)*sizeof(char));
				strcpy(info,s);
				(*G).arcs[i][j].info = info; /* 有向 */
			}
		}
	}
	(*G).kind = DG;
	return OK;
}
Status CreateDN(MGraph *G)
{ /* 采用数组(邻接矩阵)表示法,构造有向网G */
	int i,j,k,w,IncInfo;
	char s[MAX_INFO],*info;
	VertexType va,vb;

	printf("请输入有向网的顶点数，弧数，弧是否含其他信息(是：1 否：0)：");
	scanf("%d,%d,%d",&(*G).vexnum, &(*G).arcnum, &IncInfo);
	printf("请输入%d个顶点的值(<%d个字符):\n",(*G).vexnum,MAX_NAME);
	for(i = 0; i < (*G).vexnum; ++i){ /* 构造顶点向量 */
		scanf("%s",(*G).vexs[i]);
	}
	for(i = 0; i < (*G).vexnum; ++i){/* 初始化邻接矩阵 */
		for(j = 0; j < (*G).vexnum; ++j){
			(*G).arcs[i][j].adj = INFINITY; /* 网 */
			(*G).arcs[i][j].info = NULL;
		}
	}
	printf("请输入%d条弧的弧尾 弧头 权值(以空格作为间隔): \n",(*G).arcnum);
	for(k = 0;k < (*G).arcnum; ++k){
		scanf("%s%s%d%*c",va,vb,&w);  /* %*c吃掉回车符 */
		i = LocateVex(*G, va);
		j = LocateVex(*G, vb);
		(*G).arcs[i][j].adj = w; /* 有向网 */
		if(IncInfo){
			printf("请输入该弧的相关信息(<%d个字符): ",MAX_INFO);
			gets(s);
			w = strlen(s);
			if(w){
				info = (char*)malloc((w + 1) * sizeof(char));
				strcpy(info,s);
				(*G).arcs[i][j].info = info; /* 有向 */
			}	
		}
	}
	(*G).kind = DN;
   return OK;	
}
Status CreateAG(MGraph *G)
{ /* 采用数组(邻接矩阵)表示法,构造无向图G */
	int i,j,k,l,IncInfo;
	char s[MAX_INFO],*info;
	VertexType va,vb;

	printf("请输入无向图G的顶点数,边数,边是否含其它信息(是:1,否:0): ");
	scanf("%d,%d,%d", &(*G).vexnum, &(*G).arcnum, &IncInfo);
	printf("请输入%d个顶点的值(<%d个字符):\n",&(*G).vexnum, MAX_NAME);
	for(i = 0;i < (*G).vexnum; i++){/* 构造顶点向量 */
		scanf("%s",(*G).vexs[i]);
	}
	for(i = 0; i < (*G).vexnum;i++){
		for(j = 0; j < (*G).vexnum; ++j){/* 初始化邻接矩阵 */
			(*G).arcs[i][j].adj = 0;
			(*G).arcs[i][j].info = NULL;	
		}
	}
	printf("请输入%d条边的顶点1 顶点2(以空格作为间隔): \n", (*G).arcnum );
	for(k=0;k<(*G).arcnum;++k){
		scanf("%s%s%*c",va,vb);/*%*c吃掉回车符*/
		i = LocateVex((*G),va);
		j = LocateVex((*G),vb);
		(*G).arcs[i][j].adj = (*G).arcs[j][i].adj = 1; /*无向图*/
		if(IncInfo){
			printf("请输入该边的相关信息(<%d个字符): ", MAX_INFO);
			gets(s);
			l = strlen(s);
			if(l){
				info = (char*)malloc((l+1)*sizeof(char));
				strcpy(info,s);
				(*G).arcs[i][j].info = (*G).arcs[j][i].info = info; /*无向*/
			}
		}
	}
	(*G).kind = AG;
	return OK;
}

Status CreateAN(MGraph *G)
{ /* 采用数组(邻接矩阵)表示法,构造无向网G。算法7.2 */
	int i,j,k,w,IncInfo;
	char s[MAX_INFO],*info;
	VertexType va,vb;	
	printf("请输入无向网G的顶点数,边数,边是否含其它信息(是:1,否:0): ");
	scanf("%d,%d,%d",&(*G).vexnum, &(*G).arcnum, &IncInfo);
	printf("请输入%d个顶点的值(<%d个字符):\n",(*G).vexnum,MAX_NAME);
	for (i = 0; i < (*G).vexnum;++i){/* 构造顶点向量 */
		scanf("%s",(*G).vexs[i]);
	}
	for (i = 0; i < (*G).vexnum;++i){
		for (j = 0; j < (*G).vexnum;++j){
			(*G).arcs[i][j].adj = INFINITY; /* 网 */
			(*G).arcs[i][j].info = NULL;
		}
	}
	printf("请输入%d条边的顶点1 顶点2 权值(以空格作为间隔): \n",(*G).arcnum);
	for (k = 0; k < (*G).vexnum; ++k){
		scanf("%s%s%d%*c",va,vb,&w);/* %*c吃掉回车符 */
		i = LocateVex((*G),va);
		j = LocateVex((*G),vb);
		(*G).arcs[i][j].adj = (*G).arcs[j][i].adj = w;	/*无向*/
		if(IncInfo){
			printf("请输入该边的相关信息(<%d个字符): ",MAX_INFO);
			gets(s);
			w = strlen(s);
			if(w){
				info = (char*)malloc((w+1)*sizeof(char));
				strcpy(info,s);
				(*G).arcs[i][j].info = (*G).arcs[j][i].info = info; /*无向*/
			}
		}
	}
	(*G).kind = AN;
	return OK;
}
Status CreateGraph(MGraph *G)
{ /* 采用数组(邻接矩阵)表示法,构造图G。算法7.1 */
	printf("请输入图G的类型(有向图:0,有向网:1,无向图:2,无向网:3): ");
	scanf("%d",&(*G).kind);
	switch((*G).kind){
		case DG: return CreateDG(G); /* 构造有向图 */
		case DN: return CreateDN(G); /* 构造有向网 */
		case AG: return CreateAG(G); /* 构造无向图 */
		case AN: return CreateAN(G); /* 构造无向网 */
		default: return ERROR;
   }
}
void DestroyGraph(MGraph *G)
{ /* 初始条件: 图G存在。操作结果: 销毁图G */
	int i,j;
	if ((*G).kind < 2){/*有向*/
		for(i = 0; i < (*G).vexnum; ++i){
			for (j = 0; j < (*G).vexnum; ++j){
				if (((*G).arcs[i][j].adj == 1 && (*G).kind == DG)
					|| ((*G).arcs[i][j].adj != INFINITY && (*G).kind == DN)){
					if ((*G).arcs[i][j].info){
						free((*G).arcs[i][j].info);
						(*G).arcs[i][j].info = NULL;
					}
				}
			}
		}
	}
	else{ /* 无向 */
		for (i = 0; i < (*G).vexnum; ++i){ /* 释放边的相关信息(如果有的话) */
			for(j = i + 1; j < (*G).vexnum; ++j){
				if (((*G).arcs[i][j].adj == 1 && (*G).kind == AG) 
					|| ((*G).arcs[i][j].adj == INFINITY && (*G).kind == AN)){
					if((*G).arcs[i][j].info){ /* 有相关信息 */
						free((*G).arcs[i][j].info);
						(*G).arcs[i][j].info = NULL;
					}
				}
			}
		}
	}
	(*G).vexnum = 0;
	(*G).arcnum = 0;
	return;
}
VertexType* GetVex(MGraph G,int v)
{ /* 初始条件: 图G存在，v是G中某个顶点的序号。操作结果: 返回v的值 */
	if (v <0 || v >= G.vexnum){
		return ERROR;
	}
	return &G.vexs[v];
}
Status PutVex(MGraph *G,VertexType v,VertexType value)
{ /* 初始条件: 图G存在，v是G中某个顶点。操作结果: 对v赋新值value */
	int k;
	k = LocateVex(*G,v);
	if (k < 0){
		return ERROR;
	}
	strcpy((*G).vexs[k],value );
	return OK;
}
int FirstAdjVex(MGraph *G,VertexType v)
{	/* 初始条件: 图G存在,v是G中某个顶点 */
	/* 操作结果: 返回v的第一个邻接顶点的序号。若顶点在G中没有邻接顶点,则返回-1 */
	int i,j = 0,k;
	k = LocateVex(*G,v); /* k为顶点v在图G中的序号 */
	if ((*G).kind == AN || (*G).kind == DN ){/* 网 */
		j = INFINITY;
	}
	for(i = 0; i < (*G).vexnum; i++){
		if((*G).arcs[k][i].adj != j ){ 
			return i;
		}
	}
	return -1;
}
int NextAdjVex(MGraph *G,VertexType v,VertexType w)
{	/* 初始条件: 图G存在,v是G中某个顶点,w是v的邻接顶点 */
	/* 操作结果: 返回v的(相对于w的)下一个邻接顶点的序号, */
	/*           若w是v的最后一个邻接顶点,则返回-1 */
	int i,j=0,k1,k2;
	k1 = LocateVex(*G,v);
	k2 = LocateVex(*G,w);
	if ((*G).kind == AN || (*G).kind == DN){
		j = INFINITY;
	}
	for (i = k2+1; i < (*G).vexnum; i++){
		if ((*G).arcs[k1][i].adj != j){
			return j;
		}
	}
	return -1;
}

void InsertVex(MGraph *G,VertexType v)
{	/* 初始条件: 图G存在,v和图G中顶点有相同特征 */
	/* 操作结果: 在图G中增添新顶点v(不增添与顶点相关的弧,留待InsertArc()去做) */
	int i = 0;
	strcpy((*G).vexs[(*G).vexnum],v);
	for (i = 0; i < (*G).vexnum; i++){	
		if ((*G).kind%2 == 0){
			(*G).arcs[(*G).vexnum][i].adj = INFINITY;
			(*G).arcs[i][(*G).vexnum].adj = INFINITY;
		}
		else if((*G).kind % 2 != 0){
			(*G).arcs[(*G).vexnum][i].adj = 0;
			(*G).arcs[i][(*G).vexnum].adj = 0;		
		}
		(*G).arcs[(*G).vexnum][i].info = NULL; /* 初始化相关信息指针 */
		(*G).arcs[i][(*G).vexnum].info = NULL;
	}
	(*G).vexnum += 1;/* 图G的顶点数加1 */
	return;
}

Status DeleteVex(MGraph *G,VertexType v)
{	/* 初始条件: 图G存在,v是G中某个顶点。操作结果: 删除G中顶点v及其相关的弧 */
	int i,j,k;
	VRType m = 0;
	
	k = LocateVex(*G,v);/* k为待删除顶点v的序号 */
	if (k < 0){
		return ERROR;
	}
	if ((*G).kind == AN || (*G).kind == DN){
		j = INFINITY;
	}
	for(j = 0; j < (*G).vexnum; j++){
		if((*G).arcs[j][k].adj != m){ /*有弧或有边*/
			if((*G).arcs[j][k].info != NULL){/* 有相关信息 */
				free((*G).arcs[j][k].info); /* 释放相关信息 */
			}
			(*G).arcnum--; /* 修改弧数 */
		}
		if ((*G).kind == DG || (*G).kind == DN){
			if((*G).arcs[k][j].info != NULL){/* 有相关信息 */
				free((*G).arcs[k][j].info); /* 释放相关信息 */
			}
			(*G).arcnum--; /* 修改弧数 */		
		}
	}
	for(j=k+1; j < (*G).vexnum; j++){/* 序号k后面的顶点向量依次前移 */
		strcpy((*G).vexs[j-1],(*G).vexs[j]);
	}
	for(i=0; i < (*G).vexnum; i++){
		for(j=k+1; j< (*G).vexnum; j++ ){
			(*G).arcs[i][j-1] = (*G).arcs[i][j];/* 移动待删除顶点之后的矩阵元素 */
		}
	}
	for(i=0; i < (*G).vexnum; i++){
		for(j=k+1; j< (*G).vexnum; j++ ){
			(*G).arcs[j-1][i] = (*G).arcs[j][i];/* 移动待删除顶点之下的矩阵元素 */
		}
	}
	(*G).vexnum--;/* 更新图的顶点数 */
	return OK;
}
Status InsertArc(MGraph *G,VertexType v,VertexType w)
{	/* 初始条件: 图G存在,v和W是G中两个顶点 */
	/* 操作结果: 在G中增添弧<v,w>,若G是无向的,则还增添对称弧<w,v> */
	int i,l,v1,w1;
	char *info,s[MAX_INFO];
	v1 = LocateVex(*G,v);/*头*/
	w1 = LocateVex(*G,w);/*尾*/
	if(v1 < 0 || w1 < 0){
		return ERROR;
	}
	(*G).arcnum++;/* 弧或边数加1 */
	if ((*G).kind == DN || (*G).kind == AN){
		printf("请输入此弧或边的权值:");
		scanf("%d",&(*G).arcs[v1][w1].adj);
	}
	else{/* 图 */
		(*G).arcs[v1][w1].adj = 1;
	}
	printf("是否有该弧或边的相关信息(0:无 1:有): ");
	scanf("%d%*c",&i);
	if(i){
		printf("请输入该弧或边的相关信息(<%d个字符)：",MAX_INFO);
		gets(s);
		l = strlen(s);
		if(l){
			info = (char*)malloc((l+1)*sizeof(char));
			strcpy(info,s);
			(*G).arcs[v1][w1].info = info;
		}
	}
	if((*G).kind == AN || (*G).kind == AG){/*无向*/
		(*G).arcs[w1][v1].adj = (*G).arcs[v1][w1].adj;
		(*G).arcs[w1][v1].info = (*G).arcs[v1][w1].info;/* 指向同一个相关信息 */
	}
	return OK;
}

Status DeleteArc(MGraph *G,VertexType v,VertexType w)
{	/* 初始条件: 图G存在,v和w是G中两个顶点 */
	/* 操作结果: 在G中删除弧<v,w>,若G是无向的,则还删除对称弧<w,v> */
	int v1,w1;	
	v1 = LocateVex(*G,v);/*头*/
	w1 = LocateVex(*G,w);/*尾*/
	if(v1 < 0 || w1 < 0){
		return ERROR;
	}
	if((*G).kind == AG || (*G).kind == DG){
		(*G).arcs[v1][w1].adj = 0;	
	}
	else{
		(*G).arcs[v1][w1].adj = INFINITY;
	}
	if((*G).arcs[v1][w1].info != NULL){ /* 有其它信息 */
		free((*G).arcs[v1][w1].info);
		(*G).arcs[v1][w1].info = NULL;
	}
	/*无向图或表的情况下，删除对称弧*/
	if( (*G).kind == AG || (*G).kind == AN ){
		(*G).arcs[w1][v1].adj = (*G).arcs[v1][w1].adj;
		(*G).arcs[w1][v1].info = NULL;
	}
	(*G).arcnum--;
	return OK;
}
Boolean visited[MAX_VERTEX_NUM]; /* 访问标志数组(全局量) */
Status(*VisitFunc)(VertexType); /* 函数变量 */

void DFS(MGraph G,int v)
{ /* 从第v个顶点出发递归地深度优先遍历图G。算法7.5 */
	VertexType w1,v1;
	int w;

	visited[v] = TRUE;/* 设置访问标志为TRUE(已访问) */
	VisitFunc(G.vexs[v]); /* 访问第v个顶点 */
	strcpy(v1,*GetVex(G,v));
	for(w = FirstAdjVex(&G,v1); w > 0; w=NextAdjVex(&G,v1,strcpy(w1,*GetVex(G,w)))){
		if (!visited[w]){
			DFS(G,w); /* 对v的尚未访问的序号为w的邻接顶点递归调用DFS */
		}
	}
}

void DFSTraverse(MGraph G,Status(*Visit)(VertexType))
{	/* 初始条件: 图G存在,Visit是顶点的应用函数。算法7.4 */
	/* 操作结果: 从第1个顶点起,深度优先遍历图G,并对每个顶点调用函数Visit */
	/*           一次且仅一次。一旦Visit()失败,则操作失败 */
	int v;

	VisitFunc = Visit;/* 使用全局变量VisitFunc,使DFS不必设函数指针参数 */
	for (v=0; v < G.vexnum; v++){
		visited[v] = FALSE;/* 访问标志数组初始化(未被访问) */
	}
	for (v = 0; v < G.vexnum; v++){
		if(!visited[v]){
			DFS(G,v); /* 对尚未访问的顶点调用DFS */
		}
	}
}

进击的横打
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构 第七章（学习笔记一（图））
qq_45876197的博客
11-24 927
图图的定义图的其他基本概念无向图&有向图完全图子图连通图&强连通图生成树&生成森林稀疏图&稠密图顶点的度权&网有向树路径&路径长度&回路 图的定义 图（Graph）是由顶点 (Vertex) 的有穷非空集合 和顶点之间 边 的集合组成，通常表示为：G(V, E) , 其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。 |V|表示图G中顶点的个数，也称为图G的阶；|E| 表示图G中边的条数。 V = {A，B，C，D，E},|V| = 5
数据结构第七章（图---总结一）
qq_44807343的博客
08-12 300
首先看的是图的各种定义 一大堆 没仔细记 就看了没多久 因为性质太多了 会了 （1）图的创建保存方式 一 邻接矩阵法 用二维数组进行保存即可 二 邻接表 用了很多结构体数组保存点 然后在结构体中会有个首指针 这个指针专门用来保存 与该节点所连接的点 的各种信息 学会了邻接表的创建 虽然太多代码。。但是还是自己能敲出来 （2）图的遍历方式 一 深度优先搜索（dfs） 函数递归调用 由一个节点...
读书笔记之《数据结构》---第七章 图
qq_25744595的博客
10-25 322
本章目录 1.图的定义和术语 2.图的存储结构 3.图的遍历 4.图的连通性问题 图的定义和术语 图中的数据元素通常称为顶点， &amp;amp;amp;lt;v，w&amp;amp;amp;gt;是从v到w的一条弧，v是弧尾，w是弧头，此图称为有向图。 (v，w)表示v和w的一条边，此图为无向图。 n个顶点的图，有1/2n（n-1）条边的无向图称为完全图，有n（n-1）条弧的有向图称为有向完全图，很少条边或弧的称为稀疏图，反之称为稠密图。每条...
数据结构学习笔记（七）－－图
Zoe的技术博客
04-13 650
图的存储方式一般分为邻接矩阵与邻接链表。矩阵操作简单，但稀疏图时采用链表效率更高。 图的遍历：DFS（用递归实现） BFS（用队列实现，类似于树的层序遍历！）注意什么时候使用DFS什么时候使用BFS更好？ **如果估计目标顶点离开起始顶点不会太远，那么选择广度优先遍历是比较合适的，因为广度优先是一种由近及远的搜索策略； 如果估计目标顶点与起始顶点没有太大的关系，那么选择深度优先遍历是比较合适的
数据结构图专题代码
xr5827的博客
07-21 777
#include &lt;cstdio&gt; #include &lt;cstdlib&gt; #include &lt;iostream&gt; #include &lt;vector&gt; #include &lt;queue&gt; #include &lt;string&gt; #include&lt;deque&gt; using namespace::std; #define M
计算机网络-谢希仁-第五版-读书笔记.docx
12-21
在本文中，我们将对计算机网络的基本概念、网络体系结构、物理层、数据链路层、网络层、传输层、会话层、表示层、应用层等进行详细的介绍，并对相关的知识点进行总结。 一、计算机网络的基本概念 计算机网络是指...
MYSQL必知必会读书笔记第七章之数据过滤
12-15
在MySQL中，数据过滤是...随着对SQL语言的深入学习，如第一章至第十一章的笔记所涵盖的基础、版本更改、数据库操作、数据检索、排序、过滤、通配符使用以及函数应用等，将能更全面地掌握MySQL数据库管理的各个方面。
图知识总结（一）：图的基本概念、存储方式和相关算法的简单介绍
最新发布
STRANGEX-03的博客
07-15 1169
图（graph）：图 G 由两个集合 V（vertex）和 E（edge）组成，记为 G=(V, E) ，其中 V 是顶点的有限集合，记为 V(G) ，E是连接V中两个不同顶点（顶点队）的边的有限集合，记为 E(G)。有向图（digraph）：在图 G 中，如果表示边的顶点对（或序偶）是有序的，则称 G 为有向图。用 < i , j > 表示从顶点 i 到顶点 j 的一条边。无向图（undigraph）
数据结构-图的笔记(2)(图的邻接矩阵和邻接表）
m0_71069189的博客
11-22 2115
这是我个人的数据结构图部分的笔记，供大家学习。
十大算法压缩包
05-30
算法（Algorithm）是解题的步骤，可以把算法定义成解一确定类问题的任意一种特殊的方法。在计算机科学中，算法要用计算机算法语言描述，算法代表用计算机解一类问题的精确、有效的方法。算法+数据结构=程序，求解一个给定的可计算或可解的问题，不同的人可以编写出不同的程序，来解决同一个问题，这里存在两个问题：一是与计算方法密切相关的算法问题；二是程序设计的技术问题。算法和程序之间存在密切的关系。 算法是一组有穷的规则，它们规定了解决某一特定类型问题的一系列运算，是对解题方案的准确与完整的描述。制定一个算法，一般要经过设计、确认、分析、编码、测试、调试、计时等阶段。 对算法的学习包括五个方面的内容：① 设计算法。算法设计工作是不可能完全自动化的，应学习了解已经被实践证明是有用的一些基本的算法设计方法，这些基本的设计方法不仅适用于计算机科学，而且适用于电气工程、运筹学等领域；② 表示算法。描述算法的方法有多种形式，例如自然语言和算法语言，各自有适用的环境和特点；③确认算法。算法确认的目的是使人们确信这一算法能够正确无误地工作，即该算法具有可计算性。正确的算法用计算机算法语言描述，构成计算机程序，计算机程序在计算机上运行，得到算法运算的结果；④ 分析算法。算法分析是对一个算法需要多少计算时间和存储空间作定量的分析。分析算法可以预测这一算法适合在什么样的环境中有效地运行，对解决同一问题的不同算法的有效性作出比较；⑤ 验证算法。用计算机语言描述的算法是否可计算、有效合理，须对程序进行测试，测试程序的工作由调试和作时空分布图组成。
图的基本操作【严蔚敏】
MooMLu的博客
04-27 3602
图的基本操作：ADT Graph{ 数据对象V：V是具有相同特性的数据元素的集合，称为顶点集。 数据关系R：R={VR} VR={<v,w>|v,w∈V且P(v,w)，<v,w>表示从v到w的弧， 谓词P(v,w)定义了弧<v,w>的意义或信息} 基本操作： CreateGraph( &G, V, VR ) 初始条件：V是图的顶
数据结构——图的链式存储结构实现
赵满刚的博客
11-24 3866
一、邻接表Adiacency List（链式）表示法 对每个顶点vi 建立一个单链表，把与vi有关联的边的信息（即度或出度边）链接起来，表中每个结点都设为3个域；     每个单链表还应当附设一个头结点（设为2个域），存vi信息； 每个单链表的头结点另外用顺序存储结构存储。 对于任一确定的无向图邻接表不唯一 邻接表的空间复杂度为O(n+e)，多用于稀疏图的存储（e&lt;&lt;n...
[XJTUSE]数据结构学习—— 4.1 图的基本概念与实现
weixin_47692652的博客
02-10 917
[XJTUSE]数据结构学习—— 4.1 图的基本概念与实现
图遍历
陈建慧程序人生
09-02 2077
第七章 图 7.14 Status Build_AdjList(ALGraph &G)//输入有向图的顶点数,边数,顶点信息和边的信息建立邻接表{  InitALGraph(G);  scanf("%d",&v);  if(v  G.vexnum=v;  scanf("%d",&a);  if(a  G.arcnum=a;  for(m=0;m    G.vertices[m].data=getc
数据结构课设的初步程序
huangling07031190的专栏
06-20 1029
<br />#include<stdio.h><br />#include<string.h><br />#include<malloc.h><br />#include<stdlib.h><br />#include<iostream.h><br />#define INFINITY 35542//用整型最大代替正无穷<br />#define NULL 0<br />#define FALSE 0<br />#define TRUE 1<br />#define ERROR 0<br />#define
图的数组表示方法
烽火前秦路
04-09 2741
头文件：head.h // head.h (文件名) #include // 字符串函数头文件 #include // 字符函数头文件 #include // malloc()等 #include // INT_MAX等 #include // 标准输入输出头文件，包括EOF(=^Z或F6)，NULL等 #include // atoi()，exit() #include //
【数据结构】图（Graph）
小牛肉_
06-14 8016
简单对比：图（graph）：是一种较线性表和树更为复杂的数据结构，图形结构中，结点之间的关系可以是任意的，图中任意两个数据元素之间都可能相关 线性表：数据元素之间仅有线性关系，每个数据元素只有一个直接前驱和一个直接后继 树：树形结构中，数据元素之间有着明显的层次关系，并且每一层上的数据元素可能和下一层中多个元素（即其孩子结点）相关，但只能和上一层中一个元素（即其双亲结点）相关图的定义和术语 顶点
图的基本操作
weixin_30432179的博客
11-30 352
一、图的抽象数据结构类型： ADT Graph{ 数据对象V：V是具有相同特性的数据元素的集合，称为顶点集。 数据关系R：R={VR} VR={<v,w>|v,w∈V且P(v,w)，<v,w>表示从v到w的弧， 谓词P(v,w)定义了弧<v,w>的意义或信息} 基本操作： CreateGraph( &G, V, VR )...
Python基础笔记1-10章：PEP8规范与代码风格要点
字符串和列表是Python中常用的数据结构，我们可以对它们进行各种操作，如切片、连接、查找和排序等。 在第七章中，我们学习了如何使用函数来封装一段可重用的代码。函数可以增强代码的可读性和可维护性，同时也提高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

进击的横打

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值