数据结构基础（6） 图

最新推荐文章于 2021-05-14 15:18:51 发布
最新推荐文章于 2021-05-14 15:18:51 发布
阅读量545 收藏 10
点赞数 1
分类专栏： 数据结构基础 文章标签： 数据结构 算法 图论 dfs
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/captaincoke/article/details/106038593
版权

目录

图的概念与相关定义

（不再赘述）

图的存储结构

typedef struct arc
{
	int index;//邻接点的编号
	int weight;//边的权值
	struct arc *next;//指向下一个邻接点
}AR;

typedef struct mygragh
{
	int arcnum;//图中边的数量
	int vexnum;//图中顶点数量
	int type;//图的类型（比如，1表示有向图（网），0表示无向图（网））
	AR *N;//为邻接表的表头定义动态数组
	char **vexname;//存储顶点名的动态数组
	int **A;//邻接矩阵动态数组
}GH;

常见算法

DFS(深度优先搜索）

描述

DFSTraverse(G, v, Visit()); 从顶点v起深度优先遍历图G，并对每个顶点调用函数Visit一次且仅一次。与树的先根遍历很相似。主要侧重于遍历的深度，想法简单，没有考虑距离因素。（废话少说，放码过来）

代码实现
void DFSvisit(GH *G)
{
	int i,*visit;
	visit=(int *)malloc(G->vexnum*sizeof(int));//
	memset(visit,0,G->vexnum*sizeof(int));//
	int st=clock();
	for(i=0;i<G->vexnum;i++)//
	{
		if(!visit[i])//只要顶点i还未被访问
			DFS(G,visit,i);//以i为起始点对图做DFS遍历
	}
	printf("\n");//
	free(visit);//
	printf("DFS:%dms",clock()-st);
}

void DFS(GH *G,int *visit,int index)
{
//邻接表/
	AR *p;//
	printf("%s ",G->vexname[index]);//访问当前的起始点index
	visit[index]=1;//修改其访问标记
	p=G->N[index].next;//令p指向index的第一个邻接点
	while(p)//只有存在有邻接点
	{
		if(!visit[p->index])//且当前邻接点还未被访问
			DFS(G,visit,p->index);//以当前邻接点为起始点对图继续做DFS的遍历
		p=p->next;//接着遍历下一个邻接点
	}
邻接矩阵//
	/*int i,j;
	printf("%s ",G->vexname[index]);
	visit[index]=1;
	for(i=0;i<G->vexnum;i++)
	{
		if(G->A[index][i]&&visit[i]==0)
			DFS(G,visit,i);
	}*/
}

BFS(广度优先搜索）

描述

BFSTraverse(G, v, Visit()); 从顶点v起广度优先遍历图G，并对每个顶点调用函数Visit一次且仅一次。和树的层次遍历很像，考虑了距离因素，同一层次的点到顶点v的距离都是相等的

代码实现
void BFSvisit(GH *G)
{
	int i,*visit;//visit是用来做标记的数组，0表示未访问过，1表示访问过，防止重复遍历
	visit=(int *)malloc(G->vexnum*sizeof(int));//
	memset(visit,0,G->vexnum*sizeof(int));//初始，图中的每个定均未被访问，所以初始值全部为0
	int st=clock();
	for(i=0;i<G->vexnum;i++)//对图中每个顶点
	{
		if(!visit[i])//只要该顶点还未被访问
			BFS(G,visit,i);//则以该点为起始点，对图做B广度优先遍历
	}
	printf("\n");
	free(visit);//释放 visit数组
	printf("BFS:%dms",clock()-st);
}

void BFS(GH *G,int *visit,int index)
{	
///邻接表
	int *q,front=0,rear=0;//定义队列，以及队列参数
	int i;//
	AR *p;//
	q=(int *)malloc(G->vexnum*sizeof(int));//为队列分配空间
	q[rear]=index;//其实元素入队
	rear++;//
	visit[index]=1;//入队的元素设置为已访问状态，防止重复入队
	while(front!=rear)//只要队列非空
	{
		i=q[front];//读出队头元素
		printf("%s ",G->vexname[i]);//输出队头元素对应的顶点名
		front++;//
		p=G->N[i].next;//令指针p指向当前顶点对应领接表的第一个节点
		while(p)//只要当前顶点存在有邻接点
		{
			if(!visit[p->index])//只要该邻接点还未被访问
			{
				q[rear]=p->index;//将其入队
				rear++;//
				visit[p->index]=1;//修改访问标记
			}
			p=p->next;//再继续遍历下一个邻接点
		}
	}
	free(q);//释放队列数组空间
	
邻接矩阵
	/*int *q,front=0,rear=0;
	int i,j;
	q=(int *)malloc(G->vexnum*sizeof(int));
	q[rear]=index;
	rear++;
	visit[index]=1;
	while(front!=rear)
	{
		i=q[front];
		front++;
		printf("%s ",G->vexname[i]);
		for(j=0;j<G->vexnum;j++)
		{
			if(G->A[i][j]&&visit[j]==0)
			{
				q[rear]=j;
				rear++;
				visit[j]=1;
			}
		}
	}
	free(q);*/
}
TIPS

BFS和DFS运行结束后记得释放无用的空间：例如visit和q

DFS与BFS的应用

寻找两点之间的所有路径(DFS)

算法描述这与DFS十分相似，就是将起点的visitv保持为1，在递归时先令visit为1，再恢复为0，以便其余路线可以经过该可行点

void findpath(GH *G,char *start,char *end)
{
	int i,j;
	int *path;//存路径结点的序号 
	int *visit;//标志状态 
	i=findvex(start,G);
	j=findvex(end,G);
	path=(int *)malloc(G->vexnum*sizeof(int));
	path[0]=i;//第一个结点加入路径 
	visit=(int *)malloc(G->vexnum*sizeof(int));
	memset(visit,0,G->vexnum*sizeof(int));
	visit[i]=1;//将起点标位不可行 
	allpath(G,i,j,path,1,visit,0); 
}
void allpath(GH *G,int i,int j,int *path,int n,int *visit,int sum)
{
	int k;
	AR *p;
	if(i==j) 
	{
		for(k=0;k<n;k++)
		{
			printf("%s  ",G->vexname[path[k]]);
		}
		printf("路径长度为：%d",sum);
		printf("\n");
	}
	else
	{	
		p=G->N[i].next;//找到下一个可行点 
		while(p)//对所有邻接点尝试访问 
		{
			if(visit[p->index]==0)//如果该点未访问过 
			{
				path[n]=p->index;//将该点的序号加入路径
				visit[p->index]=1;//加入路径以后该点被访问过 
				allpath(G,p->index,j,path,n+1,visit,sum+p->weight);
				visit[p->index]=0;
			}
			p=p->next;//尝试下一个邻接点 
		}
	}
}
寻找所有回路（DFS）

这又与上面的寻找所有路径相似，只是将起点（也就是终点）的visit设为0，以便它能够作为终点被再次选中。

void findcycle(GH *G,char *start) 
{	//找回路，深度优先搜索，起点的visit始终设为0，每次递归完成后都会把1的visit还原为0以找到所有通路 
	int top=-1,sum=0;
	int *path=(int *)malloc(sizeof(int)*G->vexnum);
	int stid=findvex(start,G);
	int *visit=(int *)malloc(sizeof(int)*G->vexnum);
	path[++top]=stid;
	memset(visit,0,sizeof(int)*G->vexnum);
	circle(G,stid,path,top,visit,&sum);
	if(!sum)
		printf("没有回路\n");

}
void circle(GH *G,int start,int *path,int top,int *visit,int *sum)
{	
	int i;
	
	if(start==path[top]&&top>2) 
	{	//注意这里要判断该回路的长度要至少为3，2有可能只是起点与任意相邻点之间的一去一回
		(*sum)++;
		
		for(i=0;i<=top;i++)
		    printf("%s ",G->vexname[path[i]]);
		printf("\n");
	}
	else
	{	
		AR *q=G->N[path[top]].next;
		while(q)
		{	
			if(visit[q->index]==0)
			{
				path[top+1]=q->index;
				visit[q->index]=1;
				circle(G,start,path,top+1,visit,sum);
				visit[q->index]=0;
			}
			q=q->next;
		}
	}
判断图是否联通（DFS）

调用DFS的过程中在主调函数里面加一个记录联通分支数的变量，每进行一次DFS，联通分支数就加一，最后判断联通分支数是否为1即可。

判断无向图中是否有回路（DFS）

同样地记下联通分支数，如果联通分支数+点数>边数,则有回路，否则无回路

无向图中的最短路径（BFS)

从起点开始调用BFS，直到终点入队

typedef struct node
{
	int index,pa;//该点的序号和其前驱的序号 
}QU;

void findmin(GH *G,char *start,char *end)
{
	QU *q=(QU *)malloc(sizeof(QU)*G->vexnum);
	int *path=(int *)malloc(sizeof(int)*G->vexnum);
	int *visit=(int *)malloc(sizeof(int)*G->vexnum);
	memset(visit,0,sizeof(int)*G->vexnum);
	AR *p;
	int rear=-1,front=-1;
	q[++rear].index=findvex(G,start);
	q[rear].pa=front;
	while(front!=rear)
	{
		p=G->N[q[front+1].index].next;
		while(p)
		{
			if(visit[p->index]==0)
			{
				q[++rear].index=p->index;
				q[rear].pa=front+1;
				visit[p->index]=1;
				if(strcmp(G->vexname[p->index],end)==0)
				break;
			}
			p=p->next;
		}
		if(!p) front++;
		else break;
	}
	front=-1;
	int k=q[rear].pa;
	path[++front]=q[rear].index;
	while(k!=-1)
	{
		path[++front]=q[k].index;
		k=q[k].pa;
	}
	for(k=front;k>=0;k--)
	{
		printf("%s ",G->vexname[path[k]]);
	}
	printf("\n");
}
无向图中距离起点最远的那个点（BFS)

从起点开始进行BFS，最后入队的那个点

int findfar(GH *G,char *start)
{
	int *t=(int *)malloc(sizeof(int)*G->vexnum);
	int *visit=(int*)malloc(sizeof(int)*G->vexnum);
	memset(visit,0,sizeof(int)*G->vexnum);
	int front=-1,rear=-1;
	t[++rear]=findvex(G,start);
	visit[rear]=1;
	AR p,*q;
	while(front!=rear)
	{
		p=G->N[t[front+1]];
		q=p.next;
		while(q)
		{	
			if(!visit[q->index])
			{	
				t[++rear]=q->index;
				visit[q->index]=1;
			}
			q=q->next;
		}
		front++;
	 } 
	 return t[rear];
}
tips

所有与距离有关的都可以用BFS来实现，可将BFS想象成一颗树在渐渐生长，这样最长最短路径也就可以比较容易地被解释了。

最小生成树

Prim
算法描述

取图中任意一个顶点 v 作为生成树的根，之后往生成树上添加新的顶点 w。在添加的顶点 w 和已经在生成树上的顶点v 之间必定存在一条边，并且该边的权值在所有连通顶点 v 和 w 之间的边中取值最小。之后继续往生成树上添加顶点，直至生成树上含有 n-1 个顶点为止。
时间复杂度为O(n^2)，适用于稠密图

手动实现

在这里插入图片描述

Kruskal
算法描述

考虑问题的出发点: 为使生成树上边的权值之和达到最小，则应使生成树中每一条边的权值尽可能地小。
具体做法: 先构造一个只含 n 个顶点的子图 SG，然后从权值最小的边开始，若它的添加不使SG 中产生回路，则在 SG 上加上这条边，如此重复，直至加上 n-1 条边为止
时间复杂度为O(eloge)，适用于稀疏图

手动实现

在这里插入图片描述

####最小生成树程序实现
课程设计

拓扑排序

算法描述

从有向图中选取一个没有前驱的顶点，并输出之；从有向图中删去此顶点以及所有以它为尾的弧；重复上述两步，直至图空，或者图不空但找不到无前驱的顶点为止

代码实现

（考试要求手写）

int TopologicalOrder(GH *G,int *t)//拓扑排序
{
	int tops=-1;
	int topt=-1;
	int k;
	AR *p;
	int *du=(int *)malloc(sizeof(int)*G->vexnum);
	int *st=(int *)malloc(sizeof(int)*G->vexnum);
	memset(du,0,sizeof(int)*G->vexnum);
	memset(st,0,sizeof(int)*G->vexnum);
	//初始化度
	for(int i=0;i<G->vexnum;i++)
	{	
		p=G->N[i].next;
		while(p)
		{
			du[p->index]++;
			p=p->next;
		}
	 } 
	 //源点入zhai 
	 for(int i=0;i<G->vexnum;i++)
	 {
	 	if(du[i]==0)
	 	{
	 		st[++tops]=i;
	 		break;
		 }
	 }
	 //拓扑排序 
	 while(tops>=0)
	 {
	 	k=st[tops];
	 	tops--;
	 	t[++topt]=k;
	 	p=G->N[k].next;
	 	while(p)
	 	{
	 		du[p->index]--;
	 		if(du[p->index]==0)
	 		{
	 			st[++tops]=p->index;
			 }
			 p=p->next;
		 }
	 }
	 if(topt+1==G->vexnum) return 1;
	 else return 0; 
 }
AOE网

关键路径课设

最短路径

DIJKSTAR
算法描述

路径长度最短的最短路径的特点：在这条路径上，必定只含一条弧，并且这条弧的权值最小。
下一条路径长度次短的最短路径的特点：它只可能有两种情况：或者是直接从源点到该点(只含一条弧)； 或者是从源点经过顶点v1，再到达该顶点(由两条弧组成)。
再下一条路径长度次短的最短路径的特点它可能有三种情况：或者是直接从源点到该点(只含一条弧)； 或者是从源点经过顶点v1，再到达该顶点(由两条弧组成)；或者是从源点经过顶点v2，再到达该顶点。
其余最短路径的特点：它或者是直接从源点到该点(只含一条弧)； 或者是从源点经过已求得最短路径的顶点，再到达该顶点。
求最短路径的迪杰斯特拉算法：
设置辅助数组Dist，其中每个分量Dist[k] 表示 当前所求得的从源点到其余各顶点 k 的最短路径。
一般情况下，Dist[k] = <源点到顶点 k 的弧上的权值>或者 = <源点到其它顶点的路径长度>+ <其它顶点到顶点 k 的弧上的权值>
(1)在所有从源点出发的弧中选取一条权值最小的弧，即为第一条最短路径
(2)修改其它各顶点的Dist[k]值。假设求得最短路径的顶点为u，若 Dist[u]+G.arcs[u][k]<Dist[k]则将 Dist[k] 改为 Dist[u]+G.arcs[u][k]。
具体的实现方法实际上和我们最开始的分析是一致的，只不过每次比较起点到终点的连线距离时，已经提前将该数存入Dist

代码实现
typedef struct arc
{
	int index,weight;
	struct arc *next;
}AR;

typedef struct MyGraph
{
	int type;//0，表示无向网，1表示有向网
	int arcnum,vexnum;
	char **vexname;
	AR *N;
	int **A;
}GH;

void dijkstra(GH *G,int start)
{	
	int k;
	int *dis=(int *)malloc(sizeof(int)*G->vexnum); 
	int *path=(int *)malloc(sizeof(int)*G->vexnum);
	int *flag=(int *)malloc(sizeof(int)*G->vexnum);
	memset(flag,0,sizeof(int)*G->vexnum);
	//初始化
	for(int i=0;i<G->vexnum;i++)
	{
		dis[i]=G->A[start][i];
		if(dis[i]<MAX) path[i]=start;
		else path[i]=-1;
	}
	flag[start]=1;
	
	for(int i=0;i<G->vexnum-1;i++)
	{
		k=findmin(G->vexnum,flag,dis);
		if(k>0)
		{
			flag[k]=1;
			for(int h=0;h<G->vexnum;h++)
			{
				if(flag[h]==0 && dis[h]>dis[k]+G->A[k][h])
				{	
					dis[h]=dis[k]+G->A[k][h];
					path[h]=k;
				}
			 } 
		}
	}
	showpath1(G->vexnum,flag,path,dis,start);
	free(dis);
	free(path);
	free(flag);
} 
void showpath1(int n,int *flag,int *path,int *dis,int start)
{
	for(int i=0;i<n;i++)
	{
		if(i!=start)
		{
			int k=i;
			if(path[k]==-1) 
			printf("v[%d]->v[%d]:no path\n",start,k);
			else
			{	int *route=(int *)malloc(sizeof(int)*n);
				int ind=-1;
				while(k!=start)
				{	
					route[++ind]=k;
					k=path[k];		
				}
				printf("v[%d]",start);
				for(int h=ind;h>=0;h--) printf("->v[%d]",route[h]);
				printf("\tlen:%d\n",dis[i]);
			}
			
		}
	}
}
FLOYD
算法描述

从 vi 到 vj 的所有可能存在的路径中，选出一条长度最短的路径
若<vi,vj>存在，则存在路径{vi,vj} // 路径中不含其它顶点
若<vi,v1>,<v1,vj>存在，则存在路径{vi,v1,vj}// 路径中所含顶点序号不大于1
若{vi,…,v2}, {v2,…,vj}存在，则存在一条路径{vi, …, v2, …vj}// 路径中所含顶点序号不大于2
依次类推，则 vi 至 vj 的最短路径应是上述这些路径中，路径长度最小者。

代码实现
void floyd(GH *G)
{
	int **P=(int **)malloc(sizeof(int *)*G->vexnum); 
	int **D=(int **)malloc(sizeof(int *)*G->vexnum);
	for(int i=0;i<G->vexnum;i++)
	{
		P[i]=(int *)malloc(sizeof(int)*G->vexnum);
		D[i]=(int *)malloc(sizeof(int)*G->vexnum);
		for(int j=0;j<G->vexnum;j++)
		{
			D[i][j]=G->A[i][j];
			if(D[i][j]<MAX) P[i][j]=i;
			else P[i][j]=-1;
		}
	 } 
	 for(int k=0;k<G->vexnum;k++)
	 {
	 	for(int i=0;i<G->vexnum;i++)
	 	{
	 		for(int j=0;j<G->vexnum;j++)
	 		{
	 			if(D[i][j]>D[i][k]+D[k][j])
	 			{
	 				D[i][j]=D[i][k]+D[k][j];
	 				P[i][j]=k;
				 }
			 }
		 }
	 }
	 printf("WAY 2:\n");
	 for(int i=0;i<G->vexnum;i++)
	 {
	 	for(int j=0;j<G->vexnum;j++)
	 	{	
		 	if(P[i][j]!=-1&&i!=j)
	 		{
			 printf("len:%d :",D[i][j]);
			 printf("v[%d] ",i);
			 showpath3(G->vexnum,D,P,i,j);
	 		 printf("\n");
			} 
			else if(P[i][j]==-1 && i!=j)
			{
				printf("no path:v[%d]->v[%d]\n",i,j);
			}
		 }
		 
	 }
	 free(P);
	 free(D);
} 

void showpath3(int n,int **D,int **P,int st,int ed)
{
	if(st==P[st][ed])
	printf("->v[%d]",ed);
	else
	{
		showpath3(n,D,P,st,P[st][ed]);
		showpath3(n,D,P,P[st][ed],ed);
	}
}
Floyd算法应用

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
（这字实在难看，我自己都嫌弃）

Captaincoke
关注
专栏目录
数据结构——图 寻找一条路径
ZDF19的博客
12-16 1575
用DFS来实现 findPath 的功能。 因为在深度优先搜索中，路径的边集已隐含在递归过程中，因此利用DFS设计是比较容易的。 bool Network::FindPath(int v, int w, int &length, int path[]) {//Find a path from v to w, return length and path in path[0:length]
数据结构六——图
weixin_41940752的博客
04-22 284
实现有向图、无向图、有权图、无权图的邻接矩阵和邻接表表示方法 实现图的深度优先搜索、广度优先搜索 实现 Dijkstra 算法、A* 算法 实现拓扑排序的 Kahn 算法、DFS 算法 一、图的分类与表示方法 图是由顶点和边组成的一种数据结构，一组顶点V 表示顶点的集合，一组边E 表示边的集合。 图按照不同的特征可以分为以下类别: 有向图、无向图 有权图、 无权图 连通图、非连通图 图的表示 图在...
如何判断链表中存在环路
weixin_30655569的博客
07-06 204
如果你曾经想过要参加面试，像我一样，你一定看过这个问题：如何判断链表中存在环路。（我不太清楚这个问题的应用在哪里，烦请各位读者能够提示一下。） 先简单说一下我之前看到的方法。 方法一：蛮力法。 方法二：在链表中增加一个域visited，初始化都为0，从链表的头部开始走，每走过一个链表就标记visited为1，如果要访问的下一个节点的visited域为1，那么证明链表中有环。 方法三：如果不...
数据结构—图论
不忘初心，知行统一
11-26 1562
图论〔Graph Theory〕是数学的一个分支。它以图为研究对象。图论中的图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个事物间具有这种关系。 图论是一种表示 "多对多" 的关系 图是由顶点和边组成的：(可以无边，但至少包含一个顶点) 一组顶点：通常用 V(vertex) 表示顶点集合一组边：通常用
朱、刘算法：求最小树形图权值个人理解+个人详解【最小树形图模板】
mengxiang000000
04-28 5771
什么是最小树形图？相信大家如果会过来看这篇文章，想必也应该对最小生成树有所了解的，最小生成树求的是无向图的一颗生成树的最小权值。我们的最小树形图就是来解决一个有向图的一颗生成树的最小权值，对于度娘来说，最小树形图是这样定义的：最小树形图，就是给有向带权图中指定一个特殊的点root，求一棵以root为根的有向生成树T，并且T中所有边的总权值最小。 通解最小树形图的一种算法是是1965年朱永津和刘振
数据结构基础知识.doc
最新发布
06-19
数据结构基础知识是计算机科学教育的重要组成部分，无论是语言编译、操作系统、数据库系统还是人工智能领域，都离不开对数据结构的理解和应用。 1. **数据结构的概念**： 数据结构研究的对象包括数据本身以及数据...
数据结构基础，专业程序员基础
06-07
本课程“数据结构基础”旨在为学习者提供必要的数据结构知识，以提升编程能力，更好地理解和设计复杂的程序系统。 数据结构可以被定义为组织、管理、存储和检索数据的特殊方式。在计算机科学中，数据结构不仅关乎...
大学计算机基础：第6章 算法与数据结构基础.ppt
06-01
【大学计算机基础：第6章 算法与数据结构基础】 在计算机科学中，算法与数据结构是不可或缺的基础知识。本章主要讲解了这两者的基本概念及其在编程中的重要性。数据结构指的是数据的组织形式和存储方式，而算法则是...
数据结构基础课件
01-03
本数据结构基础课件详细介绍了多种关键的数据结构及其相关算法，包括线性表、栈、队列、树、二叉树、图、串、数组和广义表以及排序和查找等重要主题。 1. **线性表**：线性表是最基本的数据结构，由若干个相同类型...
算法竞赛入门经典授课教案第6章数据结构基础.doc
05-06
算法竞赛入门经典授课教案第6章数据结构基础 本章主要介绍基础数据结构，包括线性表、二叉树和图。线性表是所有元素排成一行的数据结构，重要的算法和数据结构的基础。栈和队列是两种特殊的线性表。栈是一种先进后...
数据结构－带权图
zl
11-16 2904
带权图的最小生成树 规则：总是选择权值最低的边。 带权图的最小生成树中有所有的顶点和连接它们的必要的边，且这些边的权值最小。 算法要点 从一个顶点开始，把它放入树的集合中。以下是步骤： 找到从最新的顶点到其他顶点的所有边，这些顶点不能在树的集合中。把这些边放入优先级队列。找出权值最小的边，把它和它所到达的顶点放入树的集合中。 重复以上步骤，直到所有顶点都在树的集合中。 J
1063: 带权有向图计算
chen10151015的博客
05-14 1934
题目描述 假设带权有向图G采用邻接矩阵存储，计算图的最大权值、最小权值以及对应的有向边。 输入 第一行第一个整数n表示顶点的个数（顶点编号为0到n-1），第二行表示顶点i和j，接下来是为一个n*n大小的整数矩阵，表示图的邻接关系。数字为大于0表示邻接值，-1表示不邻接，对角线为0。 输出 第一行为最大权值，第二行为有向边。第三行为最小权值，第四行为有向边。 由于OJ无法显示尖括号，所以这里用圆扩号来表示有序对。 样例输入 5 0 5 -1 23 -1 -1 0 31 56 -1 -1 -1 0 -1
【队列】队列的基本操作总结
为了远大的理想，冲锋！
08-06 807
目录 queue的常见用法 priority_queue的常见用法 队列是一种先进先出的数据结构，通常用一个队首元素front指向队首元素的前一个位置，而使用队尾指针来指向队尾元素。 清空(clear)： /*使用数组来实现队列是，初始状态为front=-1，rear=-1*/ void clear(){ front=rear=-1; } 获得队列中的元素个数(...
有权图
扬俊的小屋
09-18 6117
目录                                                             有权图 前言 带权图的数据结构 边Edge的结构设计 邻接矩阵的结构改造 邻接表的结构改造 完整代码获取 博客文章版权说明                                                                 ...
数据结构 第7讲 循环队列
rainchxy的博客
04-09 3768
数据结构 第7讲 循环队列过了一段时间，小张再也受不了这种"起早贪黑"的有车生活。为了解决胡同停车问题，小张跑了无数次居委会，终于将挡在胡同口的建筑清除，这样住在胡同尽头的小张，就可以早早回家停在家门口，每天第一个开车上班去了。现在胡同打通了，但仍然很窄，只能通过一辆车，但是可以从一端进，另一端出，画图：小汽车是线性排列，而且只能从一端进，另一端出，这就是"队列"，队列也是一种线性表，只不过它是操...
图
qq_43627104的博客
12-01 209
图的抽象数据类型定义 图的遍历是从图中某一顶点出发，对图中所有顶点访问一次且仅访问一次。 深度优先遍历 （DFS：Depth First Search） 广度优先遍历 （BFS：Broad First Search ；FIFO: First In First Out） 基本思想： 用一个一维数组存储图中顶点的信息 用一个二维数组（称为邻接矩阵）...
数据结构学习——图的邻接表（无向图，带权值有向图）
热门推荐
Advance_的博客
06-29 2万+
邻接表是数组与链表相结合的存储方法，相比于顺序存储结构（邻接矩阵），节省空间。 来个小例子（无向图）: 图1 上图邻接表的结构： 邻接表用链表来存储邻接点（分两个域，一个存顶点下标，一个存下一个邻接点的引用），通过一个类（我用了内部类，所以是private）定义邻接点： private class AdgvexType { int verNum = -1;//存储顶点...
实验六
weixin_41937706的博客
05-31 205
#include&lt;iostream&gt; using namespace std; template&lt;class T&gt; struct BiNode { T data; BiNode&lt;T&gt; *lchild,*rchild; }; template&lt;class T&gt; class BiTree { public: BiTree(){ ...
图的基本算法
一蓑烟雨
07-29 907
一、图的表示         要表示一个图G=，有两种标准方法，即邻接表和邻接矩阵。这两种表示法既可用于有向图，也可用于无向图。通常采用邻接表表示法，因为用这种方法表示稀疏图（图中边数远比点个数要少）比较紧凑。但当遇到稠密图（|E|接近于|V|^2）或必须很快判断两个给定顶点是否存在连接边时，通常采用邻接矩阵形式。         图G=的邻接表表示是由一个包含|V|个
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值