数据结构 图

最新推荐文章于 2020-08-20 15:34:13 发布
最新推荐文章于 2020-08-20 15:34:13 发布
阅读量1.4k 收藏
点赞数
分类专栏： Data structure
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zesicus/article/details/38289545
版权

图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为G(V,E),其中G表示一个图，

V是图G中顶点的集合，E是G中边的集合。

· 图中的数据元素，称之为顶点

· 图结构中不允许没有顶点

· 任意两个顶点之间都可能有关系，顶点之间的逻辑关系用边表示。

图的定义与术语：

· 图按照有无方向分为无向图和有向图。无向图由 顶点 和 边 构成，有向图由顶点和弧构成。弧有弧尾和弧头只分。

· 图按照边或弧的多少分为稀疏图和稠密图。如果任意两个顶点间都存在边叫完全图，有向的叫有向完全图。

  若无重复的边或定点到自身的边则叫简单图。

· 图中顶点之间有邻接点、依附的概念。无向图顶点边数叫做度，有向图顶点分为入度和出度。

· 图上的边或弧上带权则称为网。

· 图中顶点间存在路径，两顶点存在路径则说明是连通的，如果路径最终回到原始点则成为环，当中不重复

  的叫做简单路径。若任意两顶点都是连通的，则图就是连通图，有向则成为强连通图。图中有子图，若子图

  极大连通则就是连通分量，有向的则称为强连通分量。

· 无向图中连通且n个顶点n-1条边叫生成树。有向图中一顶点入度为0其余项点入度为1的叫有向树。一个有向图

  由若干棵有向树构成生成森林。 


邻接矩阵实现图的创建

typedef char VertexType;//顶点类型由用户定义
typedef int EdgeType;	//边上权值类型由用户定义
const MaxVer 100;	//最大顶点数
const Infinity 65535;	//65535代表∞
typedef struct
{
	VertexType vexs[MaxVer];	//顶点表
	EdgeType arc[MaxVer][MaxVer];//邻接矩阵，可看做边表
	int numVertexes,numEdges;	//图中当前顶点数和边数
}MGraph;
/*建立无向网图的邻接矩阵表示*/
void CreateMGraph(MGraph *G)
{
	int i,j,k,w;
	printf("输入顶点数和边数：\n");
	scanf("%d,%d",&G->numVertexes,&G->numEdges);//输入定点数和边数
	for(i=0;i<G->numVertexes;i++)//读入顶点信息，建立顶点表
		scanf(&G->vexs[i]);//录入顶点数据
	for(i=0;i<G->numVertexes;i++)
		for(j=0;j<G->numVertexes;j++)
			G->arc[i][j]=Infinity;	//邻接矩阵初始化，矩阵数值全为<span style="font-family: Arial, Helvetica, sans-serif;">∞</span>
	for(k=0;k<G->numEdges;k++)//读入numEdges条边，建立临界矩阵
	{
		printf("输入边(vi,vj)上的下标i，下标j和权w:\n");
		scanf("%d,%d,%d",&i,&j,&w);//输入边（vi，vj）上的权w
		G->arc[i][j]=w;
		G->arc[j][i]=G->arc[i][j];//因为是无向图，矩阵对称
	}
}

对于稀疏图来讲，用邻接表代替邻接矩阵可节省空间 

typedef char VertexType;//顶点类型由用户定义
typedef int EdgeType;	//权值由用户定义
typedef struct EdgeNode	//边表节点
{
	int adjvex;		//邻接点域，储存该顶点对应的下标
	EdgeType weight;//用于存储权值，非网图不需要
	struct EdgeNode *next;//链域，指向下一邻接点
}EdgeNode;
typedef struct VertexNode//顶点表节点
{
	VertexType data;	//顶点域，存储顶点信息
	EdgeNode *firstedge;//边表头指针
}VertexNode,AdjList[MAXVEX];
typedef struct
{
	AdjList adjList;
	int numVertexes,numEdges;//图中当前定点数和边数
}GraphAdjList;
/*建立图的邻接表结构*/
void CreateALGraph(GraphAdjList *G)
{
	int i,j,k;
	EdgeNode *e;
	printf("输入顶点数和边数\n");
	scanf("d%,d%",&G->numVertexes,&G->numEdges);//输入顶点数和边数
	for(i=0;i<G->numVertexes;i++)//读入顶点信息，建立顶点表
	{
		scanf(&G->adjList[i].data);//输入顶点信息
		G->adjList[i].firstedge=NULL;//将边表置为空表
	}
	for(k=0;k<G->numEdges;k++)	//建立边表
	{
		printf("输入边（vi，vj）上的顶点序号：\n");
		scanf("d%,d%",&i,&j);	//输入边(vi,vj)上的顶点序号
		e=(EdgeNode*)malloc(sizeof(EdgeNode));//向内存申请空间，生成边表节点
		e->adjvex=j;	//邻接序号为j
		e->next=G->adjList[i].firstedge;//将e指针指向当前顶点指向节点
		G->adjList[i].firstedge=e;//将当前顶点的指针指向e
		e=(EdgeNode*)malloc(sizeof(EdgeNode));//向内存申请空间，生成边表节点
		e->adjvex=i;	//邻接序号为i
		e->next=G->adjList[j].firstedge;//将e指针指向当前顶点指向节点
		G->adjList[j].firstedge=e;//将当前顶点的指针指向e
	}
}


图的遍历

邻接矩阵方式遍历

/*邻接矩阵方式遍历*/
typedef int Boolean;
Boolean visited[MAX];	//访问标志数组
void DFS(MGraph G,int i)
{//邻接矩阵深度优先第归算法
	int j;
	visited[i]=TRUE;
	printf("c%",G.vexs[i]);	//打印顶点，也可以其他操作
	for(j=0;j<G.numVertexes;j++)
		if(G.arc[i][j]==1&&!visited[j])
			DFS(G,j);	//对访问的邻接顶点递归调用
}
void DFSTraverse(MGraph G)
{
	int i;
	for(i=0;i<G.numVertexes;i++)
		visited[i]=FALSE;	//初始所有顶点状态都是未访问状态
	for(i=0;i<G.numVertexes;i++)
		if(!visited[i])//对未访问过的顶点调用DFS，若是连通图
			DFS(G,i);
}
邻接表遍历 

/*邻接表结构遍历*/
void DFS(GraphAdjList GL,int i)
{//邻接表的深度优先递归算法
	EdgeNode *p;
	visited[i]=TRUE;
	printf("%c",GL->adjList[i].data);//打印顶点，也可其它操作
	p=GL->adjList[i].firstedge;
	while(p)
	{
		if(!visited[p->adjvex])
			DFS(GL,p->adjvex);//对访问的邻接节点递归调用
	}
}
void DFSTraverse(GraphAdjList GL)
{//邻接表深度遍历操作
	int i;
	for(i=0;i<GL->numVertexes;i++)
		visited[i]=FALSE;	//初始化所有顶点状态都是未访问状态
	for(i=0;i<GL->numVertexes;i++)
		if(!visited[i])?//对未访问过的顶点调用DFS，若是连通图，只会执行一次
			DFS(GL,i);
}

最小生成树（也就是找到连接所有顶点权值和最小的路径图）

· 普里姆算法

/*Prim算法最小生成树*/
void MiniSpanTree_Prim(MGraph G)
{
	int min,i,j,k;
	int adjvex[MaxVer];//保存相关顶点下标
	int lowcost[MaxVer];//保存相关顶点间边权值
	lowcost[0]=0;	//初始化第一个权值为0，即v0加入生成树
				//lowcost的值为0，在这里就是此下标的顶点已加入生成树
	adjvex[0]=0;	//初始化第一个顶点下标为0
	for(i=1;i<G.numVertexes;i++)//循环除下标为0外的全部顶点
	{
		lowcost[i]=G.arc[0][i];//将v0顶点与之有边的权值存入数组
		adjvex[i]=0;	//初始化都为v0的下标
	}
	for(i=1;i<G.numVertexes;i++)
	{
		min=Infinity;	//初始化最小权值为∞
		J=1;k=0;
		while(j<G.numVertexes)//循环全部顶点
		{
			if(lowcost[j]!=0&&lowcost[j]<min)
			{//如果权值不为0且权值小于min
				min=lowcost[j];	//则让当前权值成为最小值
				k=j;	//当前最小值下标存入k
			}
			j++;
		}
		printf("(%d,%d)",adjvex[k],k);//打印当前顶点边中权值最小边
		lowcost[k]=0;	//当前顶点的权值设置为0，表示此顶点已经完成任务
		for(j=1;j<G.numVertexes;j++)//循环所有顶点
		{
			if(lowcost[j]!=0&&G.arc[k][j]<lowcost[j])
			{//若下标为k顶点各边权值小于此前这些顶点未被加入生成树权值
				lowcost[j]=G.arc[k][j];	//将较小权值存入lowcost
				adjvex[j]=k;	//将下标为k的顶点存入adjvex
			}
		}
	}
}

克鲁斯卡尔算法

//克鲁斯卡尔（Kruskal）算法
typedef struct
{//对边集数组Edge结构的定义
	int begin;
	int end;
	int weight;
}Edge;
Void MiniSpanTree_Kruskal(MGraph G)
{//Kruskal算法生成最小生成树
	int i,n,m;
	Edge edges[MAXEDGE];//定义边集数组
	int parent[MaxVex];//定义一数组用来判断边与边是否形成环路
	//此处省略将邻接矩阵G转换为边集数组edges并按权由小到大排序的代码
	for(i=0;i<G.numVertexes;i++)
		parent[i]=0;	//初始化数组值为0
	for(i=0;i<G.numEdges;i++)//循环每一条边
	{
		n=Find(parent,edges[i].begin);
		m=Find(parent,edges[i].end;);
		if(n=!m)//假如n与m不等，说明此边没有与现有生成树形成环路
		{
			parent[n]=m;//将此边的结尾顶点放入下标为起点的parents中
						//表示此顶点已经在生成树集合中
			printf("(%d,%d)%d",edges[i].begin,edges[i].end,edges[i].weight);
		}
	}
}
int Find(int *parent,int f)//查找连线顶点的尾部下标
{
	while(parent[f]>0)
		f=parent[f];
	return f;
}

最短路径（和最小生成树不同的是，最短路径所找的是一个点到另一个点最短举例的路径）

迪杰斯特拉（Dijkstra）算法

#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXEDGE 20
#define MAXVEX 20
#define INFINITY 65535

typedef int Status;	/* Status是函数的类型,其值是函数结果状态代码，如OK等 */ 


typedef struct
{
	int vexs[MAXVEX];
	int arc[MAXVEX][MAXVEX];
	int numVertexes, numEdges;
}MGraph;

typedef int Patharc[MAXVEX];    /* 用于存储最短路径下标的数组 */
typedef int ShortPathTable[MAXVEX];/* 用于存储到各点最短路径的权值和 */

/* 构件图 */
void CreateMGraph(MGraph *G)
{
	int i, j;

	/* printf("请输入边数和顶点数:"); */
	G->numEdges=16;
	G->numVertexes=9;

	for (i = 0; i < G->numVertexes; i++)/* 初始化图 */
	{
		G->vexs[i]=i;
	}

	for (i = 0; i < G->numVertexes; i++)/* 初始化图 */
	{
		for ( j = 0; j < G->numVertexes; j++)
		{
			if (i==j)
				G->arc[i][j]=0;
			else
				G->arc[i][j] = G->arc[j][i] = INFINITY;
		}
	}

	G->arc[0][1]=1;
	G->arc[0][2]=5; 
	G->arc[1][2]=3; 
	G->arc[1][3]=7; 
	G->arc[1][4]=5; 

	G->arc[2][4]=1; 
	G->arc[2][5]=7; 
	G->arc[3][4]=2; 
	G->arc[3][6]=3; 
	G->arc[4][5]=3;

	G->arc[4][6]=6;
	G->arc[4][7]=9; 
	G->arc[5][7]=5; 
	G->arc[6][7]=2; 
	G->arc[6][8]=7;

	G->arc[7][8]=4;


	for(i = 0; i < G->numVertexes; i++)
	{
		for(j = i; j < G->numVertexes; j++)
		{
			G->arc[j][i] =G->arc[i][j];
		}
	}

}

/*  Dijkstra算法，求有向网G的v0顶点到其余顶点v的最短路径P[v]及带权长度D[v] */    
/*  P[v]的值为前驱顶点下标,D[v]表示v0到v的最短路径长度和 */  
void ShortestPath_Dijkstra(MGraph G, int v0, Patharc *P, ShortPathTable *D)
{    
	int v,w,k,min;    
	int final[MAXVEX];/* final[w]=1表示求得顶点v0至vw的最短路径 */
	for(v=0; v<G.numVertexes; v++)    /* 初始化数据 */
	{        
		final[v] = 0;			/* 全部顶点初始化为未知最短路径状态 */
		(*D)[v] = G.arc[v0][v];/* 将与v0点有连线的顶点加上权值 */
		(*P)[v] = 0;				/* 初始化路径数组P为0  */       
	}

	(*D)[v0] = 0;  /* v0至v0路径为0 */  
	final[v0] = 1;    /* v0至v0不需要求路径 */        
	/* 开始主循环，每次求得v0到某个v顶点的最短路径 */   
	for(v=1; v<G.numVertexes; v++)   
	{
		min=INFINITY;    /* 当前所知离v0顶点的最近距离 */        
		for(w=0; w<G.numVertexes; w++) /* 寻找离v0最近的顶点 */    
		{            
			if(!final[w] && (*D)[w]<min)             
			{                   
				k=w;                    
				min = (*D)[w];    /* w顶点离v0顶点更近 */            
			}        
		}        
		final[k] = 1;    /* 将目前找到的最近的顶点置为1 */
		for(w=0; w<G.numVertexes; w++) /* 修正当前最短路径及距离 */
		{
			/* 如果经过v顶点的路径比现在这条路径的长度短的话 */
			if(!final[w] && (min+G.arc[k][w]<(*D)[w]))   
			{ /*  说明找到了更短的路径，修改D[w]和P[w] */
				(*D)[w] = min + G.arc[k][w];  /* 修改当前路径长度 */               
				(*P)[w]=k;        
			}       
		}   
	}
}

int main(void)
{   
	int i,j,v0;
	MGraph G;    
	Patharc P;    
	ShortPathTable D; /* 求某点到其余各点的最短路径 */   
	v0=0;
	
	CreateMGraph(&G);
	
	ShortestPath_Dijkstra(G, v0, &P, &D);  

	printf("最短路径倒序如下:\n");    
	for(i=1;i<G.numVertexes;++i)   
	{       
		printf("v%d - v%d : ",v0,i);
		j=i;
		while(P[j]!=0)
		{
			printf("%d ",P[j]);
			j=P[j];
		}
		printf("\n");
	}    
	printf("\n源点到各顶点的最短路径长度为:\n");  
	for(i=1;i<G.numVertexes;++i)        
		printf("v%d - v%d : %d \n",G.vexs[0],G.vexs[i],D[i]);     
	return 0;
}
弗洛伊德算法 

#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXEDGE 20
#define MAXVEX 20
#define INFINITY 65535

typedef int Status;	/* Status是函数的类型,其值是函数结果状态代码，如OK等 */

typedef struct
{
	int vexs[MAXVEX];
	int arc[MAXVEX][MAXVEX];
	int numVertexes, numEdges;
}MGraph;

typedef int Patharc[MAXVEX][MAXVEX];
typedef int ShortPathTable[MAXVEX][MAXVEX];

/* 构件图 */
void CreateMGraph(MGraph *G)
{
	int i, j;

	/* printf("请输入边数和顶点数:"); */
	G->numEdges=16;
	G->numVertexes=9;

	for (i = 0; i < G->numVertexes; i++)/* 初始化图 */
	{
		G->vexs[i]=i;
	}

	for (i = 0; i < G->numVertexes; i++)/* 初始化图 */
	{
		for ( j = 0; j < G->numVertexes; j++)
		{
			if (i==j)
				G->arc[i][j]=0;
			else
				G->arc[i][j] = G->arc[j][i] = INFINITY;
		}
	}

	G->arc[0][1]=1;
	G->arc[0][2]=5; 
	G->arc[1][2]=3; 
	G->arc[1][3]=7; 
	G->arc[1][4]=5; 

	G->arc[2][4]=1; 
	G->arc[2][5]=7; 
	G->arc[3][4]=2; 
	G->arc[3][6]=3; 
	G->arc[4][5]=3;

	G->arc[4][6]=6;
	G->arc[4][7]=9; 
	G->arc[5][7]=5; 
	G->arc[6][7]=2; 
	G->arc[6][8]=7;

	G->arc[7][8]=4;


	for(i = 0; i < G->numVertexes; i++)
	{
		for(j = i; j < G->numVertexes; j++)
		{
			G->arc[j][i] =G->arc[i][j];
		}
	}

}

/* Floyd算法，求网图G中各顶点v到其余顶点w的最短路径P[v][w]及带权长度D[v][w]。 */    
void ShortestPath_Floyd(MGraph G, Patharc *P, ShortPathTable *D)
{    
	int v,w,k;    
	for(v=0; v<G.numVertexes; ++v) /* 初始化D与P */  
	{        
		for(w=0; w<G.numVertexes; ++w)  
		{
			(*D)[v][w]=G.arc[v][w];	/* D[v][w]值即为对应点间的权值 */
			(*P)[v][w]=w;				/* 初始化P */
		}
	}
	for(k=0; k<G.numVertexes; ++k)   
	{
		for(v=0; v<G.numVertexes; ++v)  
		{        
			for(w=0; w<G.numVertexes; ++w)    
			{
				if ((*D)[v][w]>(*D)[v][k]+(*D)[k][w])
				{/* 如果经过下标为k顶点路径比原两点间路径更短 */
					(*D)[v][w]=(*D)[v][k]+(*D)[k][w];/* 将当前两点间权值设为更小的一个 */
					(*P)[v][w]=(*P)[v][k];/* 路径设置为经过下标为k的顶点 */
				}
			}
		}
	}
}

int main(void)
{    
	int v,w,k;  
	MGraph G;    
	
	Patharc P;    
	ShortPathTable D; /* 求某点到其余各点的最短路径 */   
	
	CreateMGraph(&G);
	
	ShortestPath_Floyd(G,&P,&D);  

	printf("各顶点间最短路径如下:\n");    
	for(v=0; v<G.numVertexes; ++v)   
	{        
		for(w=v+1; w<G.numVertexes; w++)  
		{
			printf("v%d-v%d weight: %d ",v,w,D[v][w]);
			k=P[v][w];				/* 获得第一个路径顶点下标 */
			printf(" path: %d",v);	/* 打印源点 */
			while(k!=w)				/* 如果路径顶点下标不是终点 */
			{
				printf(" -> %d",k);	/* 打印路径顶点 */
				k=P[k][w];			/* 获得下一个路径顶点下标 */
			}
			printf(" -> %d\n",w);	/* 打印终点 */
		}
		printf("\n");
	}

	printf("最短路径D\n");
	for(v=0; v<G.numVertexes; ++v)  
	{        
		for(w=0; w<G.numVertexes; ++w)    
		{
			printf("%d\t",D[v][w]);
		}
		printf("\n");
	}
	printf("最短路径P\n");
	for(v=0; v<G.numVertexes; ++v)  
	{        
		for(w=0; w<G.numVertexes; ++w)    
		{
			printf("%d ",P[v][w]);
		}
		printf("\n");
	}

	return 0;
}

脑子秀逗了……逗逼图，老子不折磨自己了！

SunnyHughLee
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法(十七)——图
菜鸟的博客
05-03 301
概述 常用概念 顶点：图中的每一个结点称为一个顶点 边：图中两个相邻顶点的路径称为边 路径：两个顶点直接的边的集合 无向图：顶点之间的路径没有方向 有向图：顶点之间的路径有方向 带权图：每个边带有权值 表示方式 图的表示方式有两种：二维数组(邻接矩阵)；链表(邻接表) 邻接矩阵 表示图中顶点之间相邻关系的矩阵，二维数组的行下标表示边的起点，二维数组的列下标表示边的终点，行下标和列下标都表示顶点，即矩阵的行列数表示顶点个数，arr[row][col]的值表示是否两个之间存在边 邻接表 邻接矩阵需要为每个
Kruskal算法学习
Eddie蚊子
12-11 223
void MiniSpanTree_Kruskal(MGraph G) // 生成最小生成树 { int i, n, m; Edge edges[MAXEDGE]; // 定义边集数组 int parent[MAXVEX]; // 定义一组数用来判断边与边是否形成环路，此处省略将邻接矩阵G转换为边集数组edges，并按照权有小到大排序的代码 for (i = 0...
最小生成树之克鲁斯卡尔（kruskal）算法
weixin_34092455的博客
02-11 519
Kruskal算法 前面讲了最小生成树的Prim算法的实现思路是，通过顶点的扩展不断地寻找最小权重的生成树，而Kruskal算法是查找最小权值的边，然后逐渐把连通分量变为一个联结全部顶点的最小生成树。 不同于 Prim算法 ，这次用边集数组结构来实现 Kruskal算法 结构很简单，包括权值，边的弧起点和终点的下标 将前面Prim例子中的图转化为边集数组，并且按照权值升序排列储...
数据结构与算法－最小生成树之克鲁斯卡尔（Kruskal)算法
越陌度阡
06-05 1268
算法步骤 1. 设G = ( V,E )，令最小生成树初始状态为只有n个顶点而无边的非联通图 T=( V，{ } )，每个顶点自成一个连通分量； 2. 在E中选取权值最小的边，若该边依附的顶点落在T中不同的连通分量上，且不构成回路，则将此边加入到T 中，否则，舍去此边，选取下一条权值最小的边； 3. 以此类推，重复第2步，直至T中所有顶点都在同一连通分量上为止。 算法实例 假设现在我们已经通过邻接矩阵得到了边集数组并按权值从小到大排列如下图。 未完待续。。。 ......
【学习笔记----数据结构19-图的最小生成树】
Will 的专栏
11-12 1235
我们把构造连通网的最小代价生成树称为最小生成树（Minimum   Cost   Spanning Tree）   普里姆（Prim）算法   也就是说，现在我们已经有一个存储结构 MGraph的G，它的arc二维数组如图所示。数组中我们用65535代表∞ 于是普里母算法代码如下。其中INFINITY权值极大值，这里用65535代表，MAXVEX为顶点个数最大值，此处大于等于9即
C语言数据结构图片********
05-16
本资料集“C语言数据结构图片”提供了一种直观的方式来理解和学习数据结构。 一、数组 数组是最基础的数据结构，它是一系列相同类型元素的集合，通过索引来访问。在C语言中，数组可以是一维、二维或多维的。一维...
redmine的数据结构图
06-06
公司需要对redmine进行二次开发；自己用了近一天时间进行数据库的梳理；并且转换成数据结构图；你二次开发redmine的利器值得拥有
数据结构教案
12-13
数据结构教案 数据结构是计算机科学中的一门重要课程，它研究的是计算机中数据的存储、组织和管理方式。数据结构的基本概念包括数据元素、数据结构、数据类型、抽象数据类型等。 数据元素是数据结构中讨论的基本...
数据结构图的基本用法
01-09
数据结构中的图的基础学习，包括图的概念，图的代码实现，图的遍历。
数据结构用C语言写的无向图的算法
03-13
数据结构用C语言写的关于 图的算法；无向图的邻接连接矩阵
图——最小生成树Kruskal算法
Revendell的博客
11-11 294
Kruskal算法的原理和本质：Kruskal算法直接以边为目标去构建，因为权值是在边上，直接去找最小权值的边来构建生成树也是很自然的想法，只不过构建时要考虑是否会形成环路而已。Kruskal算法是基于贪心的思想得到的。首先把所有的边按照权值先从小到大排列，接着按照顺序选取每条边，如果这条边的两个端点不属于同一集合，那么就用并查集算法将它们合并，直到所有的点都属于同一个集合为止。换言之，Krusk...
无向图 c语言 （数据结构）
smallliumang的博客
06-16 4660
#include #include #define  N  100 typedef struct { int vers[N];//顶点 int arcs[N][N];//邻接矩阵 int n,e;//n为顶点数，e为边 }graph; void createUDG(graph *G) { int i,j,k,a,b; printf("输入顶点数和边数："); scanf(
16、数据结构与算法 - 图（一）存储
shengdaVolleyball的博客
05-23 322
图 线性表特性; 明显层次关系, 1对多关系 图的结构, 结点之间关系任意. 二叉树有空树（只有根结点），但是图没有空图的概念。 图的结点可以形成闭环也可以不形成闭环，同样也可以不连接 带方向的叫有向图，没有方向的叫无向图 二、图的存储 连接线：无向图叫边，有向图叫弧 自己用0，没有关系就用无穷大表示(代码中用最大值表示)，有关系有权重就用权重，没有权重就用1.没有 多少个顶点就多大的数组 1、邻接矩阵（顺序存储） ...
邻接矩阵（图）基本操作：建立无向图、有向图 代码实现（C语言）
知且行的博客
02-03 6533
邻接矩阵存储结构： 创建无向图、有向图： #include<stdio.h> #include<stdlib.h> #define MaxVexNum 100 #define MaxInt 32767 //邻接矩阵 typedef int VertexType; typedef int EdgeType; typedef struct AMGraph{ Verte...
《数据结构》实验三报告（无向图邻接表的构造）
weixin_44203971的博客
01-11 4131
实验内容： 无向图邻接表的构造 一、目的和要求（需求分析）： 1、掌握邻接表的存储结构以及邻接表的建立和操作。 2、 构造一个无向图的邻接表，要求从键盘输入图的顶点数和图的边数，并显示所构造的邻接表） 实验拓展：1. 构建有向图的邻接表 2. 判断边是否存在 3. 求顶点的度数 二、程序设计的基本思想，原理和算法描述： 首先，定义图的结构，边结点等等在一步步深入，输出度，遍历等等然后在主函数...
《数据结构与算法》实验报告——无向图邻接表的构造
无限迭代中......
12-09 5414
《数据结构》实验报告 学号： 2018329621200 机器号 10-414-28 姓名： 申屠志刚 日期： 2019/12/9 程序名： main.cpp ...
图--基本概念及源码表示
weixin_45563088的博客
08-20 208
什么是图？ 表示多对多的关系 怎么在程序中表示图？ 邻接矩阵 邻接表 邻接矩阵 邻接矩阵G[N][N]——N个顶点从0到N-1编号 ，若v[i][j]==1，则（i，j）是一组边。 优点： 1 ：方便检查任意一对顶点间是否存在边 2： 方便找任一顶点的所有“邻接点” 3： 方便计算任一顶点的“度”（从该点发出的边数为“出 度”，指向该点的边数为“入度”） 邻接表 G[N]为指针数组，对应矩阵每行一个链表， 只存非0元素，每条链表上都是根N相邻的元素。 优点： 1 ：方便找任一顶点的所有“邻接点” 2：
邻接表（图）基本操作：建立无向图、有向图 深度优先遍历 广度优先遍历 代码实现（C语言）
热门推荐
知且行的博客
02-06 1万+
邻接表存储结构: 创建有（无）向图，深度优先遍历，广度优先遍历 代码实现： #include<stdio.h> #include<stdlib.h> #include<string.h> #define MaxVertexNum 100 #define MaxSize 10 //顶点数目的最大值 bool visitedBFS[MaxVertex...
数据结构图书馆里系统
最新发布
06-22
数据结构图书馆，通常指的是包含各种常用数据结构实现的软件库或模块，它为程序员提供了一组预先设计和优化过的数据结构，如数组、链表、队列、栈、树、图、哈希表等。这些数据结构是计算机科学中基础且核心的部分，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值