数据结构：图的邻接矩阵存储实现

最新推荐文章于 2024-06-21 13:32:35 发布
最新推荐文章于 2024-06-21 13:32:35 发布
阅读量2.4k 收藏 4
点赞数 3
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s634772208/article/details/45580245
版权
/******************************************************

程序：图的邻接矩阵存储实现
完成者：小单
完成时间:2013年5月31日

*******************************************************/
//测试
图片 

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

//#include <limits.h>
#define MAX_VERTEX_NUM 20   //最大顶点数
#define MAX MAX_VERTEX_NUM

#define INFINITY 0  //用0表示顶点之间无关系

#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define TRUE 1
#define FALSE 0
typedef int Status;

/*----------------用到的数据结构---队-------------------*/
typedef char QElemType;
typedef struct QNode
{
	QElemType data;
	struct QNode *next;
}QNode, *QueuePtr;
typedef struct  
{
	QueuePtr front;  //队头
	QueuePtr rear;  //队尾
}LinkQueue;
Status InitQueue(LinkQueue &Q)
{
	Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));
	if(!Q.front)
		exit(OVERFLOW);
	Q.front->next = NULL;
	return OK;
}

Status EnQueue(LinkQueue &Q, QElemType e)
{
	QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
	if(!p)
		exit(OVERFLOW);
	p->data = e;
	p->next = NULL;
	Q.rear->next = p;
	Q.rear = p;
	return OK;
}

Status DeQueue(LinkQueue &Q, QElemType &e)
{
	if(Q.front == Q.rear)
		return ERROR;
	QueuePtr p = Q.front->next;
	e = p->data;
	Q.front->next = p->next;
	if(Q.rear == p) Q.rear = Q.front;
	free(p);
	return OK;
}

int EmptyQueue(LinkQueue &Q)
{
	if(Q.front == Q.rear )
		return TRUE;
	return FALSE;
}

/*---------------------数据结构--队-----------------*/



typedef int VRType;//顶点关系类型
typedef int InfoType;  
typedef char VertexType; //顶点值类型
typedef enum{DG, DN, UDG, UDN}GraphKind;  //{有向图，有向网，无向图，无向网}
typedef struct ArcCell
{
	VRType adj;  //VRType是顶点关系类型，对无权图，用1或0表示相邻否
				//对带权图，则为权值类型
	InfoType *info;  //该弧相关信息的指针
}ArcCell, AdjMatric[MAX_VERTEX_NUM][MAX_VERTEX_NUM];

typedef struct  
{
	VertexType vexs[MAX_VERTEX_NUM];  //顶点向量
	AdjMatric arcs;  //邻接矩阵
	int vexnum, arcnum;  //图的当前顶点数与弧数
	GraphKind kind;  //图的种类标志
}MGraph;

bool visited[MAX];  //访问标志数组
Status (*VisitFunc)(MGraph &G,int v);  //函数变量

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

Status CreateDG(MGraph &G)//构造有向图
{
	//采用数组（邻接矩阵）表示法，构造有向图G
	printf("请输入有向图的顶点数与边数:\n");
	scanf("%d%d",&G.vexnum, &G.arcnum);  
	int i,j;
	printf("请输入%d个顶点的值:\n",G.vexnum);
	getchar();//取出输入流中的回车符
	for(i = 0; i < G.vexnum; ++i)
	{
		scanf("%c",&G.vexs[i]);
	}
	//scanf("%*c"); //跳过输入流中的回车符
	//char buffer = getchar(); //取出输入流中的回车符
	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;  //表示无边的相关信息
		}
	}
	int k;
	VertexType v1, v2;//顶点的临时存储变量
	for(k=0; k<G.arcnum; ++k) //构造邻接矩阵
	{
		printf("请输入第%d条边依附的顶点:\n", k+1);
		getchar(); //取出输入流中的回车符
		scanf("%c%c",&v1, &v2); //%*c  跳过回车符
		i=LocateVex(G,v1);
		j=LocateVex(G,v2);
		if(i==-1 || j==-1)
			return ERROR;  //无此顶点，构造失败，返回出错信息
		G.arcs[i][j].adj = 1;
		//因为边没有其他的相关信息，G.arcs[i][j].info== NULL，保持不变
	}
	G.kind = DG;  //有向图
	return OK;
}

Status CreateDN(MGraph &G)
{
	//采用数组（邻接矩阵）表示法，构造有向网G
	printf("请输入有向网的顶点数与边数：\n");
	scanf("%d %d",&G.vexnum, &G.arcnum);
	getchar();//取出输入流中的回车符
	int i,j;
	printf("请输入%d个顶点的值:\n",G.vexnum);
	for(i=0; i<G.vexnum; ++i)//构造顶点向量
	{
		scanf("%c",&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;  //表示无边的相关信息
		}
	}
	
	int k;
	VertexType v1, v2;//顶点的临时存储变量
	VRType w;  //顶点关系，此时代表权值
	for(k=0; k<G.arcnum; ++k) //构造邻接矩阵
	{
		printf("请输入第%d条边依附的顶点及权值:\n", k+1);
		getchar();//取出输入流中的回车符
		scanf("%c%c%d",&v1, &v2, &w);
		i=LocateVex(G,v1);
		j=LocateVex(G,v2);
		if(i==-1 || j==-1)
			return ERROR;  //无此顶点，构造失败，返回出错信息
		G.arcs[i][j].adj = w;
		//因为边没有其他的相关信息，G.arcs[i][j].info== NULL，保持不变
	}
	G.kind = DN;  //有向网
	return OK;
}

Status CreateUDG(MGraph &G)//构造无向图
{
	//采用数组（邻接矩阵）表示法，构造无向图G
	printf("请输入无向图的顶点数与边数:\n");
	scanf("%d%d",&G.vexnum, &G.arcnum);  
	int i,j;
	printf("请输入%d个顶点的值:\n",G.vexnum);
	getchar();//取出输入流中的回车符
	for(i = 0; i < G.vexnum; ++i)
	{
		scanf("%c",&G.vexs[i]);
	}
	//scanf("%*c"); //跳过输入流中的回车符
	//char buffer = getchar(); //取出输入流中的回车符
	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;  //表示无边的相关信息
		}
	}
	int k;
	VertexType v1, v2;//顶点的临时存储变量
	for(k=0; k<G.arcnum; ++k) //构造邻接矩阵
	{
		printf("请输入第%d条边依附的顶点:\n", k+1);
		getchar(); //取出输入流中的回车符
		scanf("%c%c",&v1, &v2); //%*c  跳过回车符
		i=LocateVex(G,v1);
		j=LocateVex(G,v2);
		if(i==-1 || j==-1)
			return ERROR;  //无此顶点，构造失败，返回出错信息
		G.arcs[i][j].adj = 1;
		G.arcs[j][i].adj = G.arcs[i][j].adj;  //对称弧的信息
		//因为边没有其他的相关信息，G.arcs[i][j].info== NULL，保持不变
	}
	G.kind = UDG;  //无向图
	return OK;
}


Status CreateUDN(MGraph &G)
{
	//采用数组（邻接矩阵）表示法，构造无向网G
	printf("请输入无向网的顶点数与边数：\n");
	scanf("%d %d",&G.vexnum, &G.arcnum);
	getchar();//取出输入流中的回车符
	int i,j;
	printf("请输入%d个顶点的值:\n",G.vexnum);
	for(i=0; i<G.vexnum; ++i)//构造顶点向量
	{
		scanf("%c",&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;  //表示无边的相关信息
		}
	}

	int k;
	VertexType v1, v2;//顶点的临时存储变量
	VRType w;  //顶点关系，此时代表权值
	for(k=0; k<G.arcnum; ++k) //构造邻接矩阵
	{
		printf("请输入第%d条边依附的顶点及权值:\n", k+1);
		getchar();//取出输入流中的回车符
		scanf("%c%c%d",&v1, &v2, &w);
		i=LocateVex(G,v1);
		j=LocateVex(G,v2);
		if(i==-1 || j==-1)
			return ERROR;  //无此顶点，构造失败，返回出错信息
		G.arcs[i][j].adj = w;
		//因为边没有其他的相关信息，G.arcs[i][j].info== NULL，保持不变
		G.arcs[j][i].adj = G.arcs[i][j].adj;  //置<v1,v2>的对称弧<v2,v1>;
	}
	G.kind = UDN;  //无向网
	return OK;
}

Status CreateGraph(MGraph &G)
{
	//构造图G
	printf("请输入构造的类型：(0:有向图,1:有向网，2:无向图，3:无向网):");
	scanf("%d",&G.kind);
	switch(G.kind)
	{
	case DG:return CreateDG(G);  //构造有向图
	case DN:return CreateDN(G);  //构造有向网
	case UDG:return CreateUDG(G);  //构造无向图
	case UDN:return CreateUDN(G);  //构造无向网
	default:return ERROR;
	}
}
VertexType GetVex(MGraph &G, int v)
{
	//初始条件：图G存在，v是G中某个顶点的序号
	//操作结果：若存在，则返回其值,否则返回空
	if(v >= G.vexnum || v < 0)
		return NULL;
	return G.vexs[v];
}

Status PutVex(MGraph &G,int v, VertexType value)
{
	//初始条件：图G存在，v是G中某个顶点的序号
	//操作结果：对v赋值value
	if(v >= G.vexnum || v < 0)
		return ERROR;
	G.vexs[v] = value;
	return OK;
}

int FirstAdjVex(MGraph &G, VertexType v)
{
	//初始条件：图G存在，v是G中某个顶点
	//操作结果：返回v的第一个邻接顶点，若顶点在G中没有邻接顶点，则返回"空"
	int k = LocateVex(G,v);
	if(k == -1)//无此顶点
		return -1;
	int adjValue = 0; 
	if(G.kind == DN || G.kind == UDN)
		adjValue = INFINITY;
	
	for(int i=0; i < G.vexnum; ++i)
	{
		if(G.arcs[k][i].adj != adjValue)
			return i;
	}
	return -1;
}

int NextAdjVex(MGraph &G, VertexType v, VertexType w)
{
	//初始条件：图G存在，v是G中某个顶点，w是v的邻接顶点
	//操作结果：返回v的（相对于w的）下一个邻接顶点。若w是v的最后一个邻接点，则返回“空”
	int k1=LocateVex(G,v);
	int k2=LocateVex(G,w);

	if(k1 == -1 || k2 == -1)//无此顶点
	{
		return -1;
	}
	int adjValue = 0; 
	if(G.kind == DN || G.kind == UDN)
		adjValue = INFINITY;
	for(int i=k2+1; i < G.vexnum; ++i)
	{
		if(G.arcs[k1][i].adj != adjValue)
		{
			return i;
		}
	}
	return -1;

}

Status InsertVex(MGraph &G, VertexType v)
{
	//初始条件：图G存在，v和图G某个顶点有相同的特征
	//操作结果：在图G中增添新顶点v（此时不增加关系）
	G.vexs[G.vexnum] = v;  //赋于顶点值
	for(int i=0; i <=G.vexnum; ++i)
	{
		if(G.kind%2==0)//图
		{
			G.arcs[G.vexnum][i].adj = 0;
			G.arcs[i][G.vexnum].adj = 0;
		}
		else  //网
		{
			G.arcs[G.vexnum][i].adj = INFINITY;
			G.arcs[i][G.vexnum].adj = INFINITY;
		}
	}
	G.arcs[G.vexnum][i].info = NULL; //初始化该弧的相关信息
	G.arcs[i][G.vexnum].info = NULL; //初始化该弧的相关信息
	G.vexnum++;
	
	return OK;
}

Status DeleteVex(MGraph &G, VertexType v)
{
	//初始条件：图G存在，v是G中某个顶点
	//操作结果：删除G中顶点v及其相关的弧
	int k = LocateVex(G,v);
	if(k == -1)
		return ERROR; //无此结点
	//1.从顶点向量中删除该顶点
	int i,j;
	for(i=k; i < G.vexnum-1; ++i)
	{
		G.vexs[i] = G.vexs[i+1];
	}

	//2.删除边的关系
	for(i=k; i < G.vexnum-1; ++i)
	{
		for(j=0; j < G.vexnum; ++j)
		{
			G.arcs[i][j].adj = G.arcs[i+1][j].adj;
			//因为没有设弧的相关信息，就不考虑G.arcs[][].info了
		}
	}
	for(j=k; j < G.vexnum-1; ++j)
	{
		for(i=0; i < G.vexnum; ++i)
		{
			G.arcs[i][j].adj = G.arcs[i][j+1].adj;
			//因为没有设弧的相关信息，就不考虑G.arcs[][].info了
		}
	}

	--G.arcnum;  //边数减1
	--G.vexnum;  //顶点数减1
	return OK;
}

Status InsertArc(MGraph &G, VertexType v, VertexType w)
{
	//初始条件：图G存在，v和w是G中两个顶点
	//操作结果：在G中增添弧<v,w>，若是无向的，则还增添对称弧
	int k1= LocateVex(G,v);
	int k2= LocateVex(G,w);
	if(k1==-1 || k2==-1)
		return ERROR;  //图中不存在v或w
	if(G.kind%2 == 1)//网
	{
		printf("请输入该弧的权值:");
		scanf("%d",&G.arcs[k1][k2].adj);
	}
	else // 图
	{
		G.arcs[k1][k2].adj = 1;
	}

	if(G.kind > 1) //无向
	{
		G.arcs[k2][k1].adj = G.arcs[k1][k2].adj;
	}
	++G.arcnum;  //弧数加1
	return OK;
	
}

Status DeleteArc(MGraph &G, VertexType v, VertexType w)
{
	//初始条件：图G存在，v和w是G中两个顶点
	//操作结果：在G中删除弧<v,w>，若是无向的，则还删除对称弧
	int k1= LocateVex(G,v);
	int k2= LocateVex(G,w);
	if(k1==-1 || k2==-1)
		return ERROR;  //图中不存在v或w
	if(G.kind%2 == 1)//网
	{
		G.arcs[k1][k2].adj = INFINITY;
	}
	else // 图
	{
		G.arcs[k1][k2].adj = 0;
	}
	
	if(G.kind > 1) //无向
	{
		G.arcs[k2][k1].adj = G.arcs[k1][k2].adj;
	}
	--G.arcnum;  //弧数加1
	return OK;

}

void DFS(MGraph &G, int v)
{
	//从第v个顶点出发递归地深度优先遍历图G
	visited[v] = TRUE;
	VisitFunc(G,v);  //访问第v个顶点
	for(int w = FirstAdjVex(G,GetVex(G,v)); w >= 0; w = NextAdjVex(G,GetVex(G,v),GetVex(G,w)))
		if(!visited[w])
			DFS(G,w);  //对v的尚未访问的邻接顶点w递归调用DFS
}

void DFSTraverse(MGraph &G, Status(*Visit)(MGraph &G,int v))//对图作深度优先遍历
{
	VisitFunc = Visit;  //使用全局变量VisitFunc，使DFS不必设函数指针参数
	for(int v=0; v < G.vexnum; ++v)
	{
		visited[v] = FALSE;  //访问标志数组初始化
	}
	for(v = 0; v < G.vexnum; ++v)
	{
		if(!visited[v])
			DFS(G,v);  //对尚未访问的顶点调用DFS
	}
}

void BFSTraverse(MGraph &G, Status(*Visit)(MGraph &G,int v))//对图作广度优先遍历
{
	int BFSvisited[MAX],i;
	for(i = 0; i<G.vexnum; ++i)
	{
		BFSvisited[i] = FALSE;//初始化辅助访问数组,开始顶点均为未访问的标志
	}
	LinkQueue Q;
	InitQueue(Q); //初始化辅助队列Q
	for(i=0; i < G.vexnum; ++i)
	{
		if(!BFSvisited[i])//序号为i的顶点未访问
		{
			BFSvisited[i] = TRUE;
			Visit(G,i);
			EnQueue(Q,GetVex(G,i));//序号为i的顶点入队
			while(!EmptyQueue(Q))
			{
				QElemType u;
				DeQueue(Q,u);
				for(int w=FirstAdjVex(G,u); w >=0; w=NextAdjVex(G,u,GetVex(G,w)))
				{
					if(!BFSvisited[w])
					{
						BFSvisited[w] = TRUE;
						Visit(G,w);
						EnQueue(Q,GetVex(G,w));
					}
				}
			}
		}
	}
}

Status VisitVex(MGraph &G,int v)
{
	//访问序号为v的顶点
	printf("%3c",G.vexs[v]);
	return OK;
}
void DisplayVexValue(const MGraph &G)//显示所有的顶点
{
	printf("顶点为：");
	for(int i=0; i < G.vexnum; ++i)
		printf("%c\t",G.vexs[i]);
	printf("\n");
}

void DisplayAdjMatrix(const MGraph &G)
{
	//输出邻接矩阵
	printf("\n邻接矩阵为：\n");
	for(int i=0; i<G.vexnum; ++i)
	{
		for(int j=0; j<G.vexnum; ++j)
		{
			printf("%d\t",G.arcs[i][j]);
		}
		printf("\n");
	}
}

void Panel()
{
	//操作菜单
	printf("\n");
	printf("\t\t----------------------------------------------\n");
	printf("\t\t---------------------图的操作-----------------\n\n");
	printf("\t\t     0-创建图              1-查看顶点信息     \n");
	printf("\t\t     2-更改指定顶点的值    3-插入顶点         \n");
	printf("\t\t     4-删除顶点            5-插入弧           \n");
	printf("\t\t     6-删除弧              7-深度优先遍历图   \n");
	printf("\t\t     8-广度优先遍历图      9-查看图的邻接矩阵 \n");
	printf("\t\t     10-退出                                  \n\n");
	printf("\t\t---------------------图的操作-----------------\n");
	printf("\t\t----------------------------------------------\n");
}

int main()
{
	MGraph G;
	int n;
	int i;
	VertexType v,w;
	while(1)
	{
		Panel();
		printf("请输入操作号:");
		scanf("%d",&n);
		getchar();
		switch(n)
		{
		case 0://创建图
			if(CreateGraph(G))
				printf("创建成功\n");
			else
				printf("创建失败\n");
			system("pause");
			break;
		case 1://查看顶点信息
			DisplayVexValue(G);
			system("pause");
			break;
		case 2://更改指定顶点的值
			printf("请输入更改顶点的序号：");
			scanf("%d",&i);
			getchar();
			printf("请输入顶点的新值：");
			scanf("%c",&v);
			getchar();
			PutVex(G,i,v);
			system("pause");
			break;
		case 3://插入顶点
			printf("请输入你所要插入顶点的值：");
			scanf("%c",&v);
			getchar();
			InsertVex(G,v);
			system("pause");
			break;
		case 4://删除顶点
			printf("请输入你所要删除的顶点的值：");
			scanf("%c",&v);
			getchar();
			DeleteVex(G,v);
			system("pause");
			break;
		case 5://插入弧
			printf("插入：请输入弧依赋的两个顶点的值：");
			scanf("%c%c",&v,&w);
			getchar();
			InsertArc(G,v,w);
			system("pause");
			break;
		case 6://删除弧 
			printf("删除：请输入弧依赋的两个顶点的值：");
			scanf("%c%c",&v,&w);
			getchar();
			DeleteArc(G,v,w);
			system("pause");
			break;
		case 7://深度优先遍历图
			printf("深度优先遍历的结果为：\n");
			DFSTraverse(G,VisitVex);
			printf("\n");
			system("pause");
			break;
		case 8://广度优先遍历图
			printf("广度优先遍历的结果为：\n");
			BFSTraverse(G,VisitVex);
			printf("\n");
			system("pause");
			break;
		case 9://查看图的邻接矩阵
			DisplayAdjMatrix(G);
			system("pause");
			break;
		case 10://退出
			exit(OVERFLOW);
			break;
		default:
			printf("无此操作\n");
			system("pause");
			
		}

	}

/*	printf("创建无向网\n");
	CreateUDN(G);
	for(int i=0; i<G.vexnum; ++i)
	{
		for(int j=0; j<G.vexnum; ++j)
		{
			printf("%d\t",G.arcs[i][j]);
		}
		printf("\n");
	}
*/

/*	printf("创建有向图\n");
	CreateDG(G);
	for(int i=0; i<G.vexnum; ++i)
	{
		for(int j=0; j<G.vexnum; ++j)
		{
			printf("%d\t",G.arcs[i][j]);
		}
		printf("\n");
	}
	
	

	while(1)//测试GetVex,与PutVex
	{
		system("pause");
		DisplayVexValue(G);
		printf("请输入你要查询的顶点序号：\n");
		int v;
		scanf("%d",&v);
		VertexType a = GetVex(G,v);
		if(!a)
		{
			printf("没有这个顶点\n");
		}
		else
		{
			printf("顶点为：%c\n",a);
		}
		VertexType vt;
		printf("请输入你要对所查询的顶点更改的值：\n");
		getchar();
		scanf("%c",&vt);
		PutVex(G,v,vt);

		system("pause");
		DisplayVexValue(G);//输出此时的顶点号

		printf("请输入你要查找邻接结点的结点:\n");
		getchar();
		scanf("%c",&v);
		vt = FirstAdjVex(G,v);
		if(vt)
		{
			printf("顶点%c第一个邻接结点为:%c", v, vt);
		}
		else
		{
			printf("没有第一个邻接结点");
		}
		VertexType w;
		printf("\n请输入相对位置的顶点，以便查询顶点%c的下一个邻接顶点:\n",v);
		getchar();
		scanf("%c",&w);
		vt = NextAdjVex(G,v,w);
		if(vt)
		{
			printf("顶点%c相对于顶点%c的下一个邻接顶点为:%c\n",v,w,vt);
		}
		else
		{
			printf("没有下一个邻接顶点\n");
		}
	
	}*/

	return 0;
}


shanql
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图的存储结构——邻接矩阵实现
lseaJK的博客
06-29 1281
7.2 图的存储结构7.2.1 邻接矩阵Adjacency Matrix定义无向图的邻接矩阵类模板邻接矩阵类定义类的实现运行的辅助 由于在图中，任何两个顶点之间都可能存在联系，所以无法在存储位置上反映数据元素之间的联系，因此图没有顺序存储结构。按图中顶点之间的联系，图的存储结构似乎采用多重链表表示比较恰当。但是若采用多重链表，则链表中结点的结构难以确定。如果结点中的指针数若按顶点度的最大值来设置，...
【数据结构】图的存储结构：邻接矩阵
春雪阁
06-12 1640
图的存储结构 由于图的任意两个顶点之间都可能存在联系，因此无法以数据元素在存储区中的物理位置来表示元素之间的关系，即图没有顺序存储结构，但我们可以用二维数组（矩阵）来表示元素之间的关系——邻接矩阵。除此之外还有链式存储结构，包括邻接表、十字链表和邻接多重表。其中邻接矩阵和邻接表最常用。 邻接矩阵 邻接矩阵（Adjacency Matrix）是表示顶点之间相邻关系的矩阵，存储在二维数组中...
图的建立与遍历c++实现（邻接矩阵存储）
10-14
这是一个关于图的建立与遍历的问题，用的是c++实现，邻接矩阵作为存储
数据结构：图的实现--邻接矩阵
weixin_33877885的博客
07-02 321
                         图的实现：邻接矩阵 为了表现图中顶点之间的关联，我们能够使用邻接矩阵来实现图结构。所谓的邻接矩阵。就是一个反应边与边之间联系的二维数组。这个二维数组我们用matrix[numV][numV]表示。当中numV是顶点数。 对于无权图 若顶点Vi和Vj之间有边，则matrix[Vi][Vj]=1;否则matrix[Vi][Vj]=0。 ...
数据结构-图的存储结构-邻接矩阵
最新发布
WinterXJujube的博客
06-21 545
图的结构十分复杂，不仅各个结点的度不同，各个顶点之间的路径也不尽相同。但是图的主要组成部分比较清晰，分为顶点信息和边或者弧的信息。
【数据结构】图的邻接矩阵存储实现
wenqian 'blog
07-29 8157
图的邻接表存储实现：http://blog.csdn.net/wenqian1991/article/details/24667287 图的邻接表DFS和BFS算法：http://blog.csdn.net/wenqian1991/article/details/24812393 这里则介绍图的另外一种存储方式：邻接矩阵。参考资料《大话数据结构》《C算法：卷二》 一、图的数据结构 图的邻接
数据结构：邻接矩阵
热门推荐
weixin_54197094的博客
05-13 2万+
关于如何创建邻接矩阵这件事，其实在离散数学中我们已经学过了，这里只是把它边的代码化了；
数据结构_邻接矩阵
战士小小白的博客
12-08 706
MGraph(int a[], int n, int e) { int vertexNum = n, edgeNum = e; for (int i = 0; i < vertexNum; i++) //存储顶点 { vertex[i] = a[i]; } for (int i = 0; i < vertexNum; i++) //初始化邻接矩阵 { for (int j = 0; j < vertexNum; j++) { edge[i][j] =.
头歌数据结构图的邻接矩阵存储及遍历操作
05-26
### 头歌数据结构图的邻接矩阵存储及遍历操作 #### 一、邻接矩阵存储 在数据结构中，图是一种常见的非线性结构，用于表示对象间的关系。根据边是否有方向，图可以分为有向图和无向图。而根据边是否具有权重值，又...
数据结构实验：用邻接矩阵存储，并按Prim算法求最小生成树
10-10
根据书P262习题3给定的无向带权图，用邻接矩阵作为存储结构，用prim算法构造其最小生成树。 对图G(V,E)设置集合S，存放已访问的顶点，然后每次从集合V-S中选择与集合S的最短距离最小的一个顶点(记为u)，访问并加入...
数据结构实验3.2：以邻接矩阵为存储结构的图的深度、宽度优先遍历.doc
10-29
数据结构实验报告主要探讨了如何使用邻接矩阵作为存储结构来实现图的深度优先遍历（DFS）和广度优先遍历（BFS）。在图的遍历中，这两种方法是核心的算法，用于访问图中所有节点。 深度优先遍历（DFS）是一种递归...
数据结构邻接矩阵表示
11-23
邻接矩阵算法 数据结构中常用 和大家分享一下
头歌数据结构图的邻接表存储及遍历操作
05-26
### 二、头歌数据结构图的邻接表存储 #### 1. 数据类型定义 - **顶点类型**：`VertexType` 定义为一个字符数组，用于存储顶点的名称。 - **图的种类**：`GraphKind` 定义了四种类型的图：有向图 (DG)、有向网 (DN)...
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历
10-07
在压缩包文件"数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历_1602077415"中，包含了关于这些主题的详细资料，可能包括理论解释、代码示例和练习题，帮助读者深入理解和掌握图的存储...
数据结构-邻接矩阵
2302_80362563的博客
02-17 1245
邻接矩阵，是表示图的一种常见方式，具体表现为一个记录了各顶点连接情况的呈正方形的矩阵。假设一共有以下顶点，其连接关系如图所示那么，怎么表示它们之间的连接关系呢？我们发现，各条边所连接的都是两个顶点，联想到我们之前学过的能表示两个量直接关系的数据结构，二维数组就是一个不错的选择。
数据结构（图）——邻接矩阵
irene@1999的博客
06-02 1843
图的存储结构： 比较常见的两种图的存储结构： 邻接矩阵表示法（数组表示法） 若图Ｇ是一个具有ｎ个顶点的无权图，Ｇ的邻接矩阵是具有以下性质的ｎ×ｎ矩阵Ａ： A[i,j]={1if(vi,vj)or&lt;vi,vj&gt;∈V0othersA[i,j]=\left\{\begin{matrix} 1 &amp;if (v_{i},v_{j})or&lt;v_{i},...
数据结构之图的邻接矩阵
章志强
03-30 3815
刚才,没事就随便写了一个图的邻接矩阵的部分功能,主要是邻接矩阵的定义,定义邻接矩阵,我用了先前写的三元组的代码.另外就是试着实现邻接矩阵的图的遍历.下面,我们就来看看如何实现的吧.代码是临时写的,也许有些错误. 不过,我测试还好.没发现错误.好了,我们来看代码吧:头文件:#ifndef _GRAPHIC_H_H_#define _GRAPHIC_H_H_//包含三元组头文件#i
数据结构之图-邻接矩阵
向阳上校的专栏
08-04 732
图的存储 1.邻接矩阵 数据类型 typedef int VType; typedef struct { //存储顶点信息 VType v[N]; //存储顶点间逻辑关系 int matrix[N][N]; }Graph; 图的操作 1.创建图 Graph *greate_graph() { 为图在堆区分配空间,空间全清0，g保存首地址
数据结构---图---邻接矩阵
小许子的博客
07-12 658
利用邻接矩阵的存储结构。 代码如下： //无向图的C语言实现（不含权值） #include #include /* run this program using the console pauser or add your own getch, system("pause") or input loop */ #define MAXV 10 //图的结构 typedef stru
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值