图的邻接矩阵演示

最新推荐文章于 2022-07-15 09:55:39 发布
最新推荐文章于 2022-07-15 09:55:39 发布
阅读量640 收藏 2
点赞数 2
分类专栏： 数据结构严蔚敏 文章标签： 数据结构 dfs 遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wswsnlyf/article/details/16332403
版权 
//根据网上和严蔚敏书上写的。
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#define MaxVertexNum 100						//最大顶点个数
#define QM 100									//队列的最大元素个数
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

int visited[MaxVertexNum];						//用于深度优先遍历

typedef enum {DG, Dn, UDG, UDN} GraphKind;		//有向图，有向网，无向图，无向网

typedef int VertexType;							//顶点类型

typedef struct
{
	int adj;									//相邻与否，或者权值大小
}ArcCell;

typedef struct 
{
	VertexType vexs[MaxVertexNum];				//顶点向量
	ArcCell arcs[MaxVertexNum][MaxVertexNum];	//邻接矩阵
	int vexnum;									//顶点数
	int arcnum;									//弧数
	int GraphKind;								//图的种类
}MGraph;

typedef struct									//广度优先用的队列
{
	VertexType *base;
	VertexType front, rear;
}SQueue;

int LocateVex( MGraph *M,VertexType v );		//求顶点位置
int CreatGraph( MGraph *M );					//生成图
int CreatGraphDG( MGraph *M );					//创建有向图
int CreatGraphDN( MGraph *M );					//创建有向网
int CreatGraphUDG( MGraph *M );					//创建无向图
int CreatGraphUDN( MGraph *M );					//创建无向网
int FirstAdjVex( MGraph *M, int v );			//返回v的第一个邻接节点
int NextAdjVex( MGraph *M, int v , int w);		//返回v相对于w的下一个邻接节点
void PrintMatrix( MGraph *M );					//打印邻接矩阵
void InsetVex( MGraph *M, VertexType v );		//插入节点
int DelVex( MGraph *M, VertexType v );			//删除节点
void InsertArc( MGraph *M );					//添加一条弧
void DeArc( MGraph *M );						//删掉一条弧
void DFS( MGraph *M, int v );					//DFS
void DFSTraverse( MGraph *M );					//DFS深度优先遍历
void BFSTraverse( MGraph *M );					//BFS广度优先遍历
//队列函数声明
void InitQueue( SQueue *Q );					//初始化队列
void EnQueue( SQueue *Q, int e );				//入队
void OutQueue( SQueue *Q, int *e);				//出队
int QueueEmpty( SQueue *Q );					//队列是否空


int main()
{
	int time;

	printf("请输入试验次数:");
	scanf("%d", &time);

	while(time--)
	{
		MGraph M;
		M.vexnum = M.arcnum = 0;
			
		CreatGraph( &M );
		
		PrintMatrix( &M );
		DeArc( &M );
		PrintMatrix( &M );

		DFSTraverse( &M );
		printf("\n");
		getch();

		BFSTraverse( &M );
	}

	return 0;
}
 
//求顶点位置
int LocateVex( MGraph *M, VertexType v )
{
	int k;

	for(k = 0; k < M->vexnum; k++)
		if(M->vexs[k] == v)
			return k;

	return -1;
}

//创建图的选择函数
int CreatGraph( MGraph *G )
{
	printf("输入要创建图的类型\n");
	printf("0: 退出 1:有向图 2: 有向网 3: 无向图 4: 无向网 \n");

	while( scanf("%d", &G->GraphKind) )
	{
			switch (G->GraphKind)
			{
			case 0:
				exit(-1);
			case 1:
				return CreatGraphDG( G );
			case 2:
				return	CreatGraphDN( G );
			case 3:
				return CreatGraphUDG( G );
			case 4:
				return CreatGraphUDN( G );
			default:
			{
				system("cls");
				printf("输入无效，请重新输入要创建图的类型\n");
				printf("0: 退出 1:有向图 2: 有向网 3: 无向图 4: 无向网 \n");
				continue;
			}
		}
	}
}

//创建有向图
int CreatGraphDG( MGraph *M )
{
	int i, j, k;
	int weight = 1;
	VertexType v1, v2;

	printf("请输入有向图的顶点数和弧数:\n");
	scanf("%d %d", &M->vexnum, &M->arcnum);

	//初始化邻接矩阵
	for(i = 0; i < M->vexnum; i++)
		for(j = 0; j < M->vexnum; j++)
			M->arcs[i][j].adj = 0;   //初始化所有顶点不相邻

	printf("输入有向图的%d个顶点:\n", M->vexnum);
	for(i = 0; i < M->vexnum; i++)
		scanf("%d", &M->vexs[i]);

	printf("建立弧，请输入%d条弧的顶点:\n", M->arcnum);
	for(k = 0; k < M->arcnum; k++)
	{
		scanf("%d %d", &v1, &v2);

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

		if(i < 0 || j < 0)
			return ERROR;

		M->arcs[i][j].adj = weight;
	}

	return OK;
}

//创建有向网
int CreatGraphDN( MGraph *M )
{
	int i, j, k;
	int weight;
	VertexType v1, v2;

	printf("输入有向网的顶点数和弧数:\n");
	scanf("%d %d", &M->vexnum, &M->arcnum);

	for(i = 0; i < M->vexnum; i++)
		for(j = 0; j < M->vexnum; j++)
			M->arcs[i][j].adj = 0;  //初始化所有顶点不相邻

	printf("输入网的%d个顶点:\n", M->vexnum);
	for(i = 0; i < M->vexnum; i++)
		scanf("%d", &M->vexs[i]);

	printf("输入网的%d条弧的顶点和权值:\n", M->arcnum);
	for(k = 0; k < M->arcnum; k++)
	{
		scanf("%d %d %d", &v1, &v2, &weight);
		
		i = LocateVex(M, v1);
		j = LocateVex(M, v2);

		if(i < 0 || j < 0)
			return ERROR;
		
		M->arcs[i][j].adj = weight;
	}

	return OK;
}

//创建无向图
int CreatGraphUDG( MGraph *M )
{
	int i, j, k;
	int weight = 1;
	VertexType v1, v2;

	printf("输入无向图的顶点数和弧数:\n");
	scanf("%d %d", &M->vexnum, &M->arcnum);

	for(i = 0; i < M->vexnum; i++)
		for(j = 0; j < M->vexnum; j++)
			M->arcs[i][j].adj = 0;   //初始化所有顶点不相邻

	printf("输入无向图的%d个顶点:\n", M->vexnum);
	for(i = 0; i < M->vexnum; i++)
		scanf("%d", &M->vexs[i]);

	printf("建立弧，请输入无向图的%d条弧的顶点:\n", M->arcnum);
	for(k = 0; k < M->arcnum; k++)
	{
		scanf("%d %d", &v1, &v2);

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

		if(v1 < 0 || v2 < 0)
			return ERROR;

		M->arcs[j][i].adj =M->arcs[i][j].adj = weight;
	}

	return OK;
}

//创建无向网
int CreatGraphUDN( MGraph *M )
{
	int i, j, k;
	int weight;
	VertexType v1, v2;

	printf("输入无向网的顶点数和弧数:\n");
	scanf("%d %d", &M->vexnum, &M->arcnum);

	for(i = 0; i < M->vexnum; i++)
		for(j = 0; j < M->arcnum; j++)
			M->arcs[i][j].adj = 0;

	printf("输入无向网的%d个顶点:\n", M->vexnum);
	for(i = 0; i < M->vexnum; i++)
		scanf("%d", &M->vexs[i]);

	printf("建立弧，请输入无向网%d条弧的顶点和权值:\n", M->arcnum);
	for(k = 0; k < M->arcnum; k++)
	{
		scanf("%d %d %d", &v1, &v2, &weight);
		
		 i = LocateVex(M, v1);
		 j = LocateVex(M, v2);

		 if(v1 < 0 || v2 < 0)
			 return ERROR;

		 M->arcs[i][j].adj = M->arcs[j][i].adj = weight;
	}

	return OK;
}

//打印邻接矩阵
void PrintMatrix( MGraph *M)
{
	int i, j;

	for(i = 0; i < M->vexnum; i++)
	{
		for(j = 0; j < M->vexnum; j++)
			printf("%d\t", M->arcs[i][j].adj);
		printf("\n");
	}
}

//返回v的第一个邻接节点
int FirstAdjVex( MGraph *M, int v )
{
	int i;

	for(i = 0; i < M->vexnum; i++)
		if( M->arcs[v][i].adj != 0 )
			return i;

	return -1;
}

//返回v相对于w的下一个邻接节点
int NextAdjVex( MGraph *M, int v, int w )
{
	int i;

	for(i = w+1; i < M->vexnum; i++)
		if( M->arcs[v][i].adj != 0 )
			return i;

	return -1;
}

//插入节点v
void InsertVex( MGraph *M, VertexType v )
{
	int i, j;

	printf("插入一个顶点:\n");
	M->vexs[M->vexnum++] = v;
	i = LocateVex( M, v );

	for(j = 0; j < M->vexnum; j++)
		M->arcs[i][j].adj = M->arcs[j][i].adj = 0;			//默认添加顶点和其他顶点都不相邻
}

//删除一个节点
int DelVertex( MGraph *M, VertexType v )
{
	int i, j;

	i = LocateVex( M, v );

	if( i == -1 )
	{
		printf("该节点不存在\n");
		return ERROR;
	}

	for(j = 0; j < M->vexnum; j++)
		M->arcs[i][j].adj = M->arcs[j][i].adj = 0;			//删除与该顶点邻接的弧

	for(j = i; j < M->vexnum - 1; j++)
		M->vexs[j] = M->vexs[j+1];

	M->vexnum--;

	return OK;
}

//DFS
void DFS( MGraph *M , int v )
{
	int vj;

	visited[v] = TRUE;
	printf("%d ", M->vexs[v]);

/*	
	for( vj = 0; vj < M->vexnum; vj++)
		if( !visited[vj] && M->arcs[v][vj].adj )
			DFS( M, vj );
*/

	for( vj = FirstAdjVex(M, v); vj >= 0; vj = NextAdjVex(M, v, vj) )			
		if( !visited[vj] )
			DFS( M, vj);
}

//DFS深度优先遍历
void DFSTraverse( MGraph *M )
{
	int vi;

	printf("深度遍历:\n");

	for(vi = 0; vi < M->vexnum; vi++)
		visited[vi] = FALSE;

	for(vi = 0; vi < M->vexnum; vi++)
		if( !visited[vi] )
			DFS( M, vi );
}

//广度优先遍历
void BFSTraverse( MGraph *M )
{
	int v, u, w;
	SQueue Q;

	printf("广度优先遍历:\n");

	for(v = 0; v < M->vexnum; v++)
		visited[v] = FALSE;

	InitQueue( &Q );

	for(v = 0; v < M->vexnum; v++)
		if( !visited[v] )
		{
			visited[v] = TRUE;
			printf("%d ", M->vexs[v]);

			EnQueue( &Q, v );

			while( !QueueEmpty( &Q ) )
			{
				OutQueue( &Q, &u);

				for( w = FirstAdjVex( M, u ); w >= 0; w = NextAdjVex( M, u, w) )
				{
					if( !visited[w] )
					{
						visited[w] = TRUE;
						printf("%d ", M->vexs[w]);
						EnQueue( &Q, w );
					}
				}
			}
		}
	
	printf("\n");
}

//初始化队列
void InitQueue( SQueue *Q )
{
	Q->base = (VertexType * ) malloc ( sizeof(VertexType) * QM );
	
	if( Q->base == NULL )
	{
		printf("分配内存失败\n");
		exit(-1);
	}

	Q->front = Q->rear = 0;
}

//队列是否为空
int QueueEmpty( SQueue *Q )
{
	return Q->front == Q->rear;
}

//入队
void EnQueue( SQueue *Q, int e )
{
	int t = (Q->rear + 1) % QM;

	if( t == Q->front )
	{
		printf("队列已满溢出");
		exit(-1);
	}

	Q->base[t-1] = e;
	Q->rear = t;
}

//出队
void OutQueue( SQueue *Q, int *e )
{
	if( QueueEmpty(Q) )
	{
		printf("出队失败，队列为空\n");
		exit(-1);
	}

	*e = Q->base[ (Q->front)++ ];
}

//添加一条弧
void InsertArc( MGraph *M )
{
	VertexType v1, v2;
	int weight;
	int i, j;

	printf("添加一条弧\n");

	if( M->GraphKind == 1 || M->GraphKind == 3 )		//图
	{
		printf("输入要添加的弧的两个顶点: ");
		while( scanf("%d %d", &v1, &v2) )
		{

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

			if( i < 0 || j < 0 )
			{
				printf("顶点不在图中请重新输入:");
				continue;
			}

			if( M->GraphKind == 1 )						//有向图
				M->arcs[i][j].adj = 1;
			else										//无向图
				M->arcs[i][j].adj = M->arcs[j][i].adj = 1;
			break;
		}
	}
	else
	{
		printf("输入要添加的弧的两个顶点和权值: ");
		while( scanf("%d %d %d", &v1, &v2, &weight) )
		{
			i = LocateVex( M, v1);
			j = LocateVex( M, v2);

			if( i < 0 || j < 0 )
			{
				printf("顶点不在图中请重新输入:");
				continue;
			}
			
			if( M->GraphKind == 2 )						//有向网
				M->arcs[i][j].adj = weight;
			else
				M->arcs[i][j].adj = M->arcs[j][i].adj = weight;
			break;
		}
	}
}

//删掉一条弧
void DeArc( MGraph *M )
{
	int v1, v2;
	int i, j;

	printf("请输入删掉弧的两个顶点: ");
	
	while( scanf("%d %d", &v1, &v2) )
	{
		i = LocateVex( M, v1 );
		j = LocateVex( M, v2 );

		if( i < 0 || j < 0 )
		{
			printf("该节点不在图中，请重新输入: ");
			continue;
		}

		if( M->GraphKind <= 2 )
			M->arcs[i][j].adj = 0;
		else
			M->arcs[i][j].adj = M->arcs[j][i].adj = 0;
		break;
	}
}

执念是个好少年
关注
专栏目录
图的邻接矩阵表示
wan767912626的博客
04-05 645
# include # include # include # define MAX 10 //最大顶点数 typedef struct { char vexs[MAX]; //顶点向量 int arcs[MAX][MAX]; //邻接矩阵 int vexnum,arcnum; //图的当前点数和弧数 }MGRAPH,* mgraph; void init_mgra
图的邻接矩阵
LinBun的博客
10-24 2426
图的邻接矩阵和邻接表 ps：本文主要针对还没有学过数据结构的人群，所以会尽量写得简单易懂，但用词上不一定十分准确。 一般来说，我们保存一个图常用的方法有两种，分别是邻接矩阵和邻接表。 下面我们用这张图来做例子： 这是一张无向图，无向图指的是通路没有方向的图。也就是说，如果点1和点2之间有通路，那么可以从点1到点2，也能从点2到点1。 有向图则是指通路有方向的图。也就是说，如果点1到点2有一条通路...
图的邻接矩阵，给定一个图，输出它的邻接矩阵
04-24
先给定图的类型，然后根据不同的类型，选择不同的函数，输出图的邻接矩阵。
图（领接矩阵和vector）的dfs和bfs
From2016cxg
09-24 542
//Uva572 图的dfs求连通块 #include #include #include using namespace std; int m,n; int dir[8][2] = {{-1,0},{-1,1},{0,1},{1,1},                  { 1,0},{1,-1},{0,-1},{-1,-1}}; bool vis[105][105]; cha
图的简单认识及邻接矩阵及邻接表存储
qian_xia_er的博客
05-05 525
图 由有穷非空顶点集V和边E组成。每一条边就是一个点对（v,w)。图中的数据元素称为顶点。如果点对是有序的（每一个点的下一个点是固定的），那么图被称为有向图，否则就是无向图。与图的边相关的数值叫做权值，带权的图称为网（network）. 与图有关的简单概念： （1）如果图中含有一条从一个顶点到他自身的边（v,v)，那么路径v叫做环。 （2）简单路径是指路径上所有的点都是互异的，但是第一个和最...
python将邻接矩阵输出成图的实现
09-18
这篇文章通过实例演示了如何将邻接矩阵转换为图形，并通过不同的方法展示图的表示。使用Python编程实现图的可视化，可以帮助我们更直观地理解图的结构，对于学习图论以及进行图相关的算法研究具有一定的帮助作用。...
图的邻接矩阵实现及深度优先搜索（JAVA）
04-10
这个应用程序演示了如何使用Java实现图的邻接矩阵和深度优先搜索的基本概念。 总结一下，这个话题涵盖了以下关键知识点： 1. 图的邻接矩阵表示法：使用二维数组存储图中节点的关系。 2. Java中实现邻接矩阵：创建一...
邻接矩阵表示的带权有向图网演示程序.doc
10-05
【邻接矩阵表示的带权有向图】是一种在图论中表示图的数据结构，尤其适用于稠密图（边的数量接近于所有顶点对的数量）。在这个数据结构中，图的每个顶点用一个数组索引表示，而每条边则通过矩阵中的元素来表示。对于...
图的存储——邻接矩阵与邻接表
cosplay2010的博客
07-15 2323
有向图最常见的存储方式有两种邻接矩阵和邻接表。
基于邻接矩阵实现简单图的一些基本操作
kfyty725的博客
11-23 783
基于邻接矩阵实现简单图的一些基本操作C/C++ 代码：MGraph.h 代码：LinkQueue.h 代码： 偶尔记录一下，原来图的算法也没有那么难，废话不多说，直接上代码 C/C++ 代码： MGraph.h 代码： #include&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; #include&amp;amp
图的基本操作（基于邻接矩阵
Serenity0614的博客
11-28 2149
本文是数据结构（Java版）中国工信出版集团一书的读书笔记 图的插入操作包括插入顶点和插入边 1.weight范围：weight 在0到正无穷之间。若越界，则无边，取值是正无穷 2.若I、j满足：0≤I，j 3.i==j，自身环，抛出无效参数异常 public void insertEdge(int i,int j,int weight){ if(i != j){
图的BFS（广度优先）实现C语言
学习笔记，仅供参考
03-27 4680
实现如图（邻接矩阵）的BFS 核心代码： void BFStraverse(MGraph G) { int i, j; SqQueue Q; //辅助队列 for (i = 0; i < G.numVertexes; i++) visited[i] = 0; //初始化都为0 InitQueue(&Q); //初始化辅助队...
邻接矩阵遍历算法c语言,[数据结构]C语言实现，邻接矩阵实现图的广度优先遍历...
weixin_42516710的博客
05-23 512
#define _CRT_SECURE_NO_WARNINGS#include #include #define VERTEX_MAX 128/*最大顶点数*/#define MAXVALUE 1024typedef enum { False, True } boolean;boolean visited[VERTEX_MAX];typedef struct SeqQueue{int data[V...
图的广度优先遍历算法(BFS)
weixin_43670251的博客
03-21 9224
图的广度优先遍历算法 (BFS) 1. 算法概述 在对图的遍历，过程中为了避免重复访问我们设置了一个辅助数组visited[ ] 用来标记某顶点是否被访问过。(0表示未被访问，1代表已经访问过) 图的广度优先算法与二叉树的层次遍历算法相似，基本思想为：首先从起始顶点v出发，访问顶点v，并将其入队；顶点v出队，依次访问与v相邻接未被访问过的顶点w1,w2,…,wi，并将其依次入队；然后顶点w1出队，依次访问与w1相邻接未被访问的顶点，并将其入队；然后顶点w2出队，依次访问与w2相邻接未被访问的顶点，并将其入队
BFS--广度优先搜索--图的邻接表
wan767912626的博客
04-11 483
# include # include # include # define MAX 20 //顶点最大值 typedef struct ARCNODE { int num; //该边所指的顶点的位置 struct ARCNODE *next; //指向下一条边的指针 }arcnode; //表的结点 typedef struct VNODE { char
【数据结构】图以及图的遍历（深度遍历和广度遍历）
qq_25218219的博客
11-12 4522
图 在数学中，图是描述于一组对象的结构，其中某些对象对在某种意义上是“相关的”。这些对象对应于称为顶点的数学抽象（也称为节点或点），并且每个相关的顶点对都称为边（也称为链接或线）。通常，图形以图解形式描绘为顶点的一组点或环，并通过边的线或曲线连接。 图形是离散数学的研究对象之一。 ------百度百科 6.1 基本术语 图：记为 G＝( V, E ) 其中：V 是G
图的邻接矩阵深度遍历
最新发布
12-21
下面是一个示例代码来演示图的邻接矩阵深度遍历： ```python # 定义一个图的邻接矩阵 graph = [[0, 1, 1, 0], [1, 0, 1, 1], [1, 1, 0, 1], [0, 1, 1, 0]] # 定义一个函数来进行深度遍历 def dfs(graph, start,...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值