以邻接表邻接矩阵创建图，深度优先遍历与广度优先遍历

已于 2022-05-30 14:54:00 修改
阅读量1.4k 收藏 22
点赞数 4
文章标签： 深度优先 宽度优先 c语言
于 2022-05-30 13:56:32 首次发布
原文链接：https://blog.csdn.net/qq_51553982/article/details/117571545
版权

参考其他博客，修改了一点点细节，没有过多简介，深度优先遍历和广度优先遍历过程可参考他人，附代码

修改一下，运行时有一处细节，邻接矩阵建立图时，对应输入的时字母，邻接表输入的时下标

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

//邻接矩阵：基于数组->用一个一维数组存储顶点，用一个二位数组存储边
//邻接表：基于链表->用一个一维数组或者一个链表来存储所有顶点

#define max 100
#define countless 32767
typedef enum { FALSE, TRUE }sf;
sf visit[max];

//邻接矩阵
typedef struct graph
{
	char vexs[max];//顶点
	int arcs[max][max];//邻接矩阵
	int vexnum;//顶点数
	int edgenum;//边数
}g;

//获取顶点v的下标
int location(g* node, char v)
{
	for (int i = 0; i < node->vexnum; i++)
	{
		if (v == node->vexs[i])
		{
			return i;//返回下标
		}
		else
		{
			/*printf("顶点不存在\n");*/
		}
	}
	return -1;
}


//创建无向图
void creategraph1(g* node)
{
	//输入边数和顶点数
	printf("输入顶点数：");
	scanf("%d", &node->vexnum);
	printf("输入边数：");
	scanf("%d", &node->edgenum);
	//用户输入顶点
	for (int i = 0; i < node->vexnum; i++)
	{
		printf("请输入第%d个顶点：",i+1);
		scanf(" %c", &node->vexs[i]);
		/*fflush(stdin);*/
	}
	//矩阵初始化
	for (int i = 0; i < node->vexnum; i++)
	{
		for (int j = 0; j < node->vexnum; j++)
		{
			node->arcs[i][j] = 0;//让矩阵置空为0，即点都不连通
		}
	}
	//构建无向图的邻接矩阵
	char v1, v2;
	int n, m;
	printf("请输入边之间的关系(例：AB连通->AB):\n");
	for (int i = 0; i < node->edgenum; i++)
	{
		/*fflush(stdin);*/
		scanf(" %c%c", &v1,&v2);
		n = location(node, v1);//获取顶点的下标
		m = location(node, v2);
		if (n == -1 || m == -1)
		{
			printf("顶点不存在\n");
			return;
		}
		else
		{
			node->arcs[n][m] = 1;//无向图只要连通就是1
			node->arcs[m][n] = 1;
		}
	}
}

//创建有向图
void creategraph2(g* node)
{
	//输入顶点数和边数
	printf("请输入顶点数：");
	scanf("%d", &node->vexnum);
	printf("请输入边数：");
	scanf("%d", &node->edgenum);
	//输入顶点
	for (int i = 0; i < node->vexnum; i++)
	{
		printf("请输入第%d个顶点：", i + 1);
		scanf(" %c", &node->vexs[i]);
	}
	//邻接矩阵初始化
	for (int i = 0; i < node->vexnum; i++)
	{
		for (int j = 0; j < node->vexnum; j++)
		{
			node->arcs[i][j] = 0;
		}
	}
	//创建有向图的邻接矩阵
	char v1, v2;
	int n, m;
	printf("请输入边之间的关系(例：AB有序连通->AB)：\n");
	for (int i = 0; i < node->edgenum; i++)
	{
		scanf(" %c%c", &v1,&v2);
		n = location(node, v1);
		m = location(node, v2);
		if (n == -1 || m == -1)
		{
			printf("顶点不存在\n");
			return;
		}
		else
		{
			node->arcs[n][m] = 1;//有方向所以只要一个
		}
	}
}

void print1(g* node)
{
	printf("邻接矩阵为：\n");
	for (int i = 0; i < node->vexnum; i++)
	{
		printf("\t%c", node->vexs[i]);
	}
	printf("\n");
	for (int i = 0; i < node->vexnum; i++)
	{
		printf("%c\t", node->vexs[i]);
		for (int j = 0; j < node->vexnum; j++)
		{
			printf("%d\t", node->arcs[i][j]);
		}
		printf("\n\n");
	}
}

//队列结构体
typedef struct queue
{
	int data[max];
	int front;
	int rear;
}que;

//初始化队列
void initque(que* qu)
{
	qu->front = qu->rear = 0;
}

//判断队空
int empty(que* qu)
{
	if (qu->front == qu->rear)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

//入队
void push(que* qu, int x)
{
	if (qu->rear + 1 == max)
	{
		printf("队满无法入队");
	}
	else
	{
		qu->data[qu->rear] = x;
		qu->rear++;
	}
}

//出队
int pop(que* qu)
{
	int temp;
	if (qu->rear == qu->front)
	{
		printf("队列为空无法出队\n");
	}
	else
	{
		qu->front++;
		temp = qu->data[qu->front - 1];
		return temp;
	}
}

//打印队列
void print(que* node)
{
	if (node->front == node->rear)
	{
		printf("队列为空无法打印\n");
	}
	else
	{
		printf("当前队列为：\n");
		for (int i = node->front; i < node->rear; i++)
		{
			printf("%d\t", node->data[i]);
		}
		printf("\n");
	}
}

//深度优先算法DFS
void DFSuse1(g* node,int i)
{
	printf("%c\t", node->vexs[i]);
	visit[i] =TRUE;
	for (int j = 0; j < node->vexnum; j++)
	{
		if (node->arcs[i][j] == 1 && !visit[j])
		{
			DFSuse1(node, j);
		}
	}
}

void DFS1(g* node)
{
	int i;
	for (i = 0; i < node->vexnum; i++)
	{
		visit[i] = FALSE;
	}
	for (i = 0; i < node->vexnum; i++)
	{
		if (!visit[i])
		{
			DFSuse1(node, i);
		}
	}
}


//广度优先算法BFS
void BFSuse1(g* node, int k)
{
	int i, j;
	que* qu;
	qu = (que*)malloc(sizeof(que));
	initque(qu);
	visit[k] = TRUE;
	push(qu, k);
	printf("%c\t", node->vexs[k]);
	while (empty(qu) != 1)
	{
		i = pop(qu);
		for (j = 0; j < node->vexnum; j++)
		{
			if (node->arcs[i][j] == 1 && !visit[j])
			{
				printf("%c\t", node->vexs[j]);
				visit[j] = TRUE;
				push(qu, j);
			}
		}
	}
}

void BFS1(g* node)
{
	for (int i = 0; i < node->vexnum; i++)
	{
		visit[i] = FALSE;
	}
	for (int i = 0; i < node->vexnum; i++)
	{
		if (!visit[i])
		{
			BFSuse1(node, i);
		}
	}
}

//图的邻接表实现
//顶点存在一维数组中，边的信息存在链表中
//边表的结构体
typedef struct Edge
{
	int edgedata;//数据域,存储顶点的下标
	struct Edge* next;//指针域
}edge;

//顶点表的结构体
typedef struct Vnode
{
	char nodedata;//真实数据
	edge* next_to_edge;
}vn, vnode[max];

//图的结构体
typedef struct listgraph
{
	vnode nodelist;
	int list_edgenum;
	int list_vexnum;
}lg;

//邻接表创建无向图
void creategraph3(lg* node)
{
	edge* e;
	printf("输入顶点数：");
	scanf("%d", &node->list_vexnum);
	printf("输入边数：");
	scanf("%d", &node->list_edgenum);
	//输入顶点
	for (int i = 0; i < node->list_vexnum; i++)
	{
		printf("请输入第%d个顶点：", i + 1);
		scanf(" %c", &node->nodelist[i].nodedata);
		node->nodelist[i].next_to_edge = NULL;
	}
	//邻接表初始化
	int v1, v2;
	printf("请输入边之间的关系(例：AB连通->01):\n");
	for (int i = 0; i < node->list_edgenum; i++)
	{
		scanf("%d %d", &v1,&v2);
		e = (edge*)malloc(sizeof(edge));
		e->edgedata = v2;
		e->next = node->nodelist[v1].next_to_edge;//把末尾结点的指针域给新结点
		node->nodelist[v1].next_to_edge = e;//原结点指针域后继为新结点
		
		e = (edge*)malloc(sizeof(edge));
		e->edgedata = v1;
		e->next = node->nodelist[v2].next_to_edge;//把末尾结点的指针域给新结点
		node->nodelist[v2].next_to_edge = e;//原结点指针域后继为新结点
	 
	}

}

//邻接表创建有向图
void creategraph4(lg* node)
{
	//输入边数和顶点数
	edge* e;
	printf("输入顶点数：");
	scanf("%d", &node->list_vexnum);
	printf("输入边数：");
	scanf("%d", &node->list_edgenum);
	//输入顶点
	for (int i = 0; i < node->list_vexnum; i++)
	{
		printf("请输入第%d个顶点：", i + 1);
		scanf(" %c", &node->nodelist[i].nodedata);
		node->nodelist[i].next_to_edge = NULL;
	}
	//邻接表初始化
	int v1, v2;
	printf("请输入边之间的关系(例：AB连通->0 1):\n");
	for (int i = 0; i < node->list_edgenum; i++)
	{
		scanf("%d %d", &v1, &v2);
		e = (edge*)malloc(sizeof(edge));
		if (e == NULL)
		{
			printf("error!内存申请失败\a");
			return;
		}
		else
		{
			e->edgedata = v2;
			e->next = node->nodelist[v1].next_to_edge;//把末尾结点的指针域给新结点
			node->nodelist[v1].next_to_edge = e;//原结点指针域后继为新结点
		}
	}
}

//邻接表的打印
void print2(lg* node)
{
	edge* e;
	printf("邻接表为：\n");
	for (int i = 0; i < node->list_vexnum; i++)
	{
		e = node->nodelist[i].next_to_edge;
		while (e != NULL)
		{
			printf("结点 %c ->结点 %c\t\t", node->nodelist[i].nodedata, node->nodelist[e->edgedata].nodedata);
			e = e->next;
		}
		printf("\n\n");
	}
}

//邻接表的深度优先DFS
int visited1[max];
void DFSuse2(lg* node, int i)
{
	edge* p;
	visited1[i] = 1;
	printf("%c\t", node->nodelist[i].nodedata);
	p = node->nodelist[i].next_to_edge;
	while (p)
	{
		if (!visited1[p->edgedata])
		{
			DFSuse2(node, p->edgedata);
		}
		p = p->next;
	}
}
void DFS2(lg* node)
{
	printf("*");
	int i;
	for (i = 0; i < node->list_vexnum; i++)
	{
		visited1[i] = 0;
	}
	for (i = 0; i < node->list_vexnum; i++)
	{
		if (!visited1[i])
		{
			DFSuse2(node, i);
		}
	}
}

//邻接表的BFS
int visit2[max];
void BFS2(lg* node)
{
	que* qu = (que*)malloc(sizeof(que));
	for (int i = 0; i < node->list_vexnum; i++)
	{
		visit2[i] = 0;
	}
	initque(qu);
	for (int i = 0; i < node->list_vexnum; i++)
	{
		visit2[i] = 1;
		printf("*");
		printf("%c\n", node->nodelist[i].nodedata);
		push(qu, i);
		while (empty(qu) != 1)
		{
			pop(qu);
			edge* e = node->nodelist[i].next_to_edge;
			while (e)
			{
				if (!visit2[e->edgedata])
				{
					visit2[e->edgedata] = 1;
					printf("%c\n", node->nodelist[e->edgedata].nodedata);
					push(qu, e->edgedata);
				}
				e = e->next;
			}
			printf("\n");
		}
	}
}


 
int main()
{
	int choose;
	g* node = (g*)malloc(sizeof(g));
	lg* listnode = (lg*)malloc(sizeof(lg));
	while (1)
	{
		printf("*****************************图的基本操作*****************************\n");
		printf("*****************************1.创建无向图（邻接矩阵）*****************\n");
		printf("*****************************2.创建有向图（邻接矩阵）*****************\n");
		printf("*****************************3.创建无向图（邻接表）*******************\n");
		printf("*****************************4.创建有向图（邻接表）*******************\n");
		printf("*****************************5.广度优先算法（邻接矩阵）***************\n");
		printf("*****************************6.深度优先算法（邻接矩阵）***************\n");
		printf("*****************************7.广度优先算法（邻接表）*****************\n");
		printf("*****************************8.深度优先算法（邻接表）*****************\n");
		printf("*****************************10.退出exit******************************\n");
		printf("**********************************************************************\n");
		printf("请输入你的选择：");
		scanf("%d", &choose);
		if (choose == 10)
		{
			printf("程序退出》》》");
			break;
		}
		switch (choose)
		{
			case 1:
				creategraph1(node);
				print1(node);
				break;
			case 2:
				creategraph2(node);
				print1(node);
				break;
			case 3:
				creategraph3(listnode);
				print2(listnode);
				break;
			case 4:
				creategraph4(listnode);
				print2(listnode);
				break;
			case 5:
				printf("图的邻接矩阵广度优先遍历为：\n");
				BFS1(node);
				printf("\n");
				break;
		    case 6:
				printf("图的邻接矩阵深度优先遍历为：\n");
				DFS1(node);
				printf("\n");
				break;
			case 7:
				printf("图的邻接表广度优先遍历为：\n");
				BFS2(listnode);
				printf("\n");
				break;
			case 8:
				printf("图的邻接表深度优先遍历为：\n");
				DFS2(listnode);
				printf("\n");
				break;
			default:
				printf("error!\a\n");
				break;
		}
	}
}

m0_54806993
关注
建立图(邻接矩阵、邻近表任选其一)的存储结构、实现图的深度优先遍历和广度优先遍历。
Scrutiny的博客
05-04 7442
#include &lt;iostream&gt;#include &lt;stdlib.h&gt;using namespace std;const int DefaultVertices=100;const int maxWeight=1000;typedef int E;typedef char T;class Graphmtx{private:    T *VerticesList;   ...
分别用邻接矩阵和邻接表实现图的深度优先遍历和广度优先遍历_图的BFS、DFS
weixin_39527768的博客
11-23 4273
BFS、DFS分别为广度优先搜索和深度优先搜索的英文首字母缩写。先考虑树的BFS、DFS。树的BFS即层序遍历。层序遍历先访问根结点，再逐个访问根结点的子结点，再逐个访问上述子结点的子结点，以此类推，直至访问过所有结点。树的DFS有三种（先序遍历、中序遍历、后序遍历），这里只说先序遍历。先序遍历先访问根结点，再逐个先序遍历根结点的所有子树。（由递归的定义可知，容易用递归算法实现（函数的递归用到了调...
邻接表或者邻接矩阵为存储结构实现连通无向图的深度优先和广度优先遍历
12-06
程序设计任务： 设计一个程序，实现以邻接表或者邻接矩阵为存储结构，实现连通无向图的深度优先和广度优先遍历。基本要求：以邻接表或者邻接矩阵为存储结构，实现连通无向图的深度优先和广度优先遍历。以用户指定的结点为起点，分别输出每种遍历下的结点访问序列和相应生成树的边集。测试数据：教科书p168图7.13(a)。
图的操作及应用（以邻接矩阵或邻接表方式建立无向图，并分别利用深度优先遍历和广度优先遍历方法输出各结点元素。）
weixin_52416700的博客
12-19 2404
主要运用： 1．图的邻接矩阵和邻接表存储结构； 2．图的深度优先遍历和广度优先遍历算法，复习栈和队列的应用； 3．图的最小生成树、最短路径等应用及算法思想。 实现功能：以邻接矩阵或邻接表方式建立无向图，并分别利用深度优先遍历和广度优先遍历方法输出各结点元素。 #include <iostream> typedef int ElemType; #define MaxSize 100 #define MAXVEX 100 #define INF 32767 typedef .
图论（2） 无向图的实现（邻接表） 图的遍历
dianlu7964的博客
05-21 403
用邻接表实现了一个无向图，在实现时，包含了添加和删除顶点，添加和删除边，size方法（顶点个数），isEmpty方法，广度和深度优先迭代器1，成员变量，构造方法，数组扩展 private VNode[] VNodes; //将顶点放在数组中 private int nodeCount; //顶点个数,也表示下一个可用的顶点数组下标 ...
数据结构 实验五1） 采用邻接矩阵/邻接表建立图（无向图，有向图，无向网络，有向网络）； 2） 采用深度优先/广度优先搜索方式遍历图；
热门推荐
修竹的博客
06-09 1万+
实验目的： 1. 掌握图的邻接矩阵和邻接表的存储结构； 2. 验证图在不同存储结构下遍历操作的实现。 3. 掌握图的实际应用 实验内容： 采用邻接矩阵/邻接表建立图（无向图，有向图，无向网络，有向网络）； 采用深度优先/广度优先搜索方式遍历图； #include <iostream> #include <stdio.h...
分别用邻接矩阵和邻接表实现图的深度优先遍历和广度优先遍历_数据结构之：图...
weixin_39915815的博客
11-21 2711
导读1. 什么是图？图的存储方式？2. 图的遍历（深度优先搜索，广度优先搜索）3. 最短路径1. 什么是图？图的存储方式？　　前面总结了“树”这种数据结构，而这篇博客总结的是更为复杂的一种数据结构：图（graph），它表明了物件与物件之间的“多对多”的一种复杂关系。图包含了两个基本元素：顶点（vertex, 简称V）和边（edge,简称E）。有向图与无向图　　如果给图的每条边规定一个方向，那么得到...
数据结构图的邻接矩阵,邻接表存储表示，图的深度优先搜索遍历，广度优先搜索遍历
10-07
本主题将深入探讨图的两种常见存储方式——邻接矩阵和邻接表，以及如何进行深度优先搜索（DFS）和广度优先搜索（BFS）遍历。 **邻接矩阵**是一种直观且简单的图存储方法。对于一个有n个顶点的图，邻接矩阵是一个n×...
建立图的邻接矩阵或邻接表存储并在此基础上实现图的深度优先遍历和广度优先遍历.doc
10-10
"建立图的邻接矩阵或邻接表存储并在此基础上实现图的深度优先遍历和广度优先遍历" 本文档主要介绍了图的存储方式，包括邻接矩阵和邻接表两种存储方法，并在此基础上实现了图的深度优先遍历和广度优先遍历。 一、图...
C++实现图的邻接矩阵存储和广度、深度优先遍历实例分析
09-03
本实例重点讨论了邻接矩阵的实现，并展示了如何进行广度优先遍历(BFS)和深度优先遍历(DFS)。邻接矩阵是一种二维数组，其中的每个元素表示图中两个节点之间是否存在边。如果节点i与节点j之间存在边，则邻接矩阵的[i]...
假设图中数据元素类型是字符型，请采用邻接矩阵或邻接表实现图的以下基本操作： （1）构造图（包括有向图、有向网、无向图、无向网）； （2）根据深度优先遍历图。
06-09
1、图和网的区别：网是带权值的图 有向和无向的区别：有向直接标出谁指向谁，无向是有向的特例，有弧，说明也有弧。 构图： ①　确定顶点数，弧数，是否有权值 ②　输入每个顶点，弧，权值 ③　若是无向，则需实现弧与的同置 2、图的深度优先搜索遍历类似于树的先根遍历，沿着初始顶点出发的一条路径，尽可能深入地前进，直到所有顶点被访问完；用visited[]来存储顶点的访问情况，初始时所有顶点皆为未访问FALSE，访问一个顶点之后就被标记为已访问TRUE。
利用邻接矩阵做存储结构——对图进行深度搜索遍历以及广度搜索遍历——C++
m0_62946714的博客
11-10 496
利用邻接矩阵做图的存储结构来进行深度搜索遍历以及广度搜索遍历。
数据结构与算法：30张图弄懂“图的两种遍历方式”
AI科技大本营
04-03 5469
点击上方↑↑↑蓝字关注我们~「2019 Python开发者日」全日程揭晓，请扫码咨询 ↑↑↑作者 | 程序员吴师兄转载自五分钟学算法（ID:CXYxiaowu）1 引言遍...
基于邻接表储存的图的深度优先和广度优先遍历
分享不仅为了他人，同时也为了自己
11-02 4962
一.深度优先遍历是连通图的一种遍历方法： 设x是当前被访问顶点，在对x做过访问标记后，选择一条从x出发的未检测过的边(x， y)。若发现顶点y已访问过，则重新选择另一条从x出发的未检测过的边，否则沿边(x，y) 到达未曾访问过的y，对y访问并将其标记为已访问过；然后从y开始搜索，直到搜索完从y 出发的所有路径，即访问完所有从y出发可达的顶点之后，才回溯到顶点x，并且再选
暑假训练总结
sdau20163940的博客
08-25 303
转眼之间，暑假一个月的时间就飞逝了。其实回过头来，你会发现时间过得真的很快，时间是抓不住的，关键是你如何利用时间，使有限的时间发挥最大的效率，提高时间的利用率。回过头，总结一下一个暑假的工作成果，其实也是一种收获。 首先，一进入假期我们就把精力投入到了DP上面，DP在ACM中非常重要的，同时又是竞赛中的难点，因为该算法时间效率高，代码量少，多元性很强，主要考察自己的思维能力和建模的抽象能力以及自
C语言实现基于邻接表的完全无向图生成，图的深度优先搜索与广度优先搜索
rather_than的博客
08-24 1788
采用邻接表作为数据结构，创建了完全无向图，创建了测试用有向图，实现了图的广度与深度优先搜索
分别用邻接矩阵和邻接表实现图的深度优先遍历和广度优先遍历_BFS 广度优先搜索...
weixin_39890102的博客
11-21 864
图，一种可以表示对象复杂连接关系的数据结构。其较可以其他数据结构而言，可以很方便描述地图、电路、网络等拓扑结构。本文将介绍图的描述方法和基本的图搜索算法——BFS 广度优先搜索图定义图(Graph)，是由一组顶点(Vertex)和一组能够将两个顶点相连的边(Edge)所组成。具体地，根据边是否有方向，可划分为有向图、无向图；根据边是否有权重值，可划分为加权图、无加权图。如下图所示，其是一个顶点数V...
以邻接表方式建立无向图，分别利用深度优先遍历和广度优先遍历方法输出各结点元素（数据结构）
记录学编程后遇到的问题，注意点以及相关知识
12-14 5899
实验目的 掌握图的邻接矩阵和邻接表存储结构； 掌握图的深度优先遍历和广度优先遍历算法，复习栈和队列的应用； 掌握图的最小生成树、拓扑排序等应用及算法思想。 实验内容 以邻接矩阵或邻接表方式建立无向图，并分别利用深度优先遍历和广度优先遍历方法输出各结点元素。 Source Code #include<stdio.h> #include<stdlib.h> typedef int ElemType; #define MaxSize 100 #define MAXV 100 #defi
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值