图的存储与深搜广搜

已于 2022-04-01 00:06:55 修改
阅读量645 收藏
点赞数
分类专栏： 图 文章标签： c++ 数据结构
于 2022-03-27 00:00:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45888103/article/details/123766543
版权

图

首先关于图的一些定义

箭头

<v,w>:意思是指箭头由v指向w，其中箭头是v，箭尾是w。如下图所示：

无向图：

两个点之间没有具体指向的图就是无向图。<v,w>==<w,v>。如下图所示：

有向图

两个点之间有具体的箭头指向。<v,w>不等于<w,v>

邻接表：

通常用邻接表来记录图上个节点之间的连接关系

如下图所示：

这个图的意思是：首先用一个表来记录所有顶点的信息（对应蓝色列表），同时表中的每一栏后面都接有一个链表（对应绿色的链表）用来记录这个顶点连接的其他点信息。

给每一个节点分别表上编号（0，1，2，3，4）

然后观察图可以知道节点A连接的节点有B,C,D所以A表中以A头节点的链表就和节点1(B),3(D),2(C)连成一个新链表。其他同理，但是由于这是无向图，所以以A节点位头节点的链表包含有节点D,同时以D节点位头节点的链表也要包含有节点A。

矩阵

用矩阵来表示图的信息，每个节点的下标是[x,y]，如果[x,y]=1，就说明节点x,y是相连的。否则就是没有相连的关系。

但是矩阵由于有很多的没用信息0，会浪费很多空间，所以如果存储大量信息时通常使用邻接表来存储。
下面是代码演示：
假设图是这样的：

首先书写结构体用于存储图中的一些信息。
typedef struct Enode {
	int ivex;
	struct Enode* next_edge;
}Enode;

typedef struct Vnode {
	char data;
	struct Vnode* first_edge;
};

typedef struct PLgraph {
	int edge_num;
	int node_num;
	Vnode* arr[MAX_SIZE];
};

现在创建邻接表来存储无向图
PLgraph* store_undirected_graph() {
	char vexs[] = { 'A','B','C','D','E','F','G' };
	char edges[][2] = {
		{'A','C'},
		{'A','D'},
		{'A','F'},
		{'B','C'},
		{'C','D'},
		{'E','G'},
		{'F','G'}
	};

    //记录顶点个数
	int len1 = (sizeof(vexs) / sizeof(vexs[0]));
    //记录弧的条数
	int len2 = (sizeof(edges) / sizeof(edges[0]));
	
    //记录箭头点的信息
	char c1;
    //记录箭尾点的信息
	char c2;

    //记录箭头点的存储位置
	int p1;
    //记录箭尾点的位置
	int p2;

    //箭头顶点
	Enode* node1;
    //箭尾顶点
	Enode* node2;

	PLgraph* G = (PLgraph*)calloc(1, sizeof(PLgraph));

	//初始化邻接表中个顶点信息
	for (int i = 0; i < len1; i++) {
		G->arr[i]->data = vexs[i];
		G->arr[i]->first_edge = NULL;
	}

	//初始化链表节点之间的关系
	for (int i = 0; i < len2; i++) {
		c1 = edges[i][0];
		c2 = edges[i][1];

		p1 = find_position(c1, G, len1);
		p2 = find_position(c2, G, len1);

		node1 = (Enode*)calloc(1, sizeof(Enode));
		node1->ivex = p1;

		node2 = (Enode*)calloc(1, sizeof(Enode));
		node2->ivex = p2;

		if (G->arr[p1]->first_edge == NULL) {
			G->arr[p1]->first_edge = node2;
		}
		else {
			link_last(G->arr[p1]->first_edge, node2);
		}
		
		if (G->arr[p2]->first_edge == NULL) {
			G->arr[p2]->first_edge = node1;
		}
		else {
			link_last(G->arr[p2]->first_edge, node1);
		}
	}
    //返回存储好了的邻接表
	return G;
}
邻接表的显示结果为

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-usL8y51d-1648309976644)(图.assets/image-20220326000228231.png)]

可以发现存储结果是正确的

对于图的遍历操作
DFS

也就是对应二叉树的后序遍历操作

代码演示

void DFS(int* visit, PLgraph* G, int i) {
	if (visit[i])return;
	visit[i] = 1;

	Enode* node = G->arr[i]->first_edge;
	printf("%c ", G->arr[i]->data);
	while (node) {
		if (!visit[node->ivex])
			DFS(visit, G, node->ivex);
		node = node->next_edge;
	}
	return ;
}

void DFS_traverse(PLgraph* G) {
	int visit[MAX_SIZE] = {};
	printf("DFS:\n");
	for (int i = 0; i < G->node_num; i++) {
		DFS(visit, G, i);
	}
	printf("\n");
	return;
}
BFS：广搜（对应二叉树的层序遍历）
代码演示
void BFS(PLgraph* G) {
	int visit[MAX_SIZE] = {};
	int queue[MAX_SIZE] = {};
	int head = 0;
	int tail = 0;

	printf("BFS\n");
	for (int i = 0; i < G->node_num; i++) {
		if (visit[i] == 0) {
			printf("%c ", G->arr[i]->data);
			queue[tail++] = i;
			visit[i] = 1;
		}
		while (head != tail) {
			Enode* node = G->arr[queue[head++]]->first_edge;
			while (node) {
				if (visit[node->ivex] != 1) {
					visit[node->ivex] = 1;
					queue[tail++] = node->ivex;
					printf("%c ", G->arr[node->ivex]->data);
				}
				node = node->next_edge;
			}
		}
	}
	return;
}
最终结果

在这里插入图片描述

有向图

有向图的代码很简单，就是把无向图那个相互连接的代码改写成单向连接即可。

PLgraph* store_directed_graph() {
	char vexs[] = { 'A','B','C','D','E','F','G' };
	char edges[][2] = {
		{'A','C'},
		{'A','D'},
		{'A','F'},
		{'B','C'},
		{'C','D'},
		{'E','G'},
		{'F','G'}
	};

	char c1;
	char c2;

	int p1;
	int p2;

	PLgraph* G = (PLgraph*)calloc(1, sizeof(PLgraph));
	G->edge_num = sizeof(edges) / sizeof(edges[0]);
	G->node_num = sizeof(vexs) / sizeof(vexs[0]);

	for (int i = 0; i < G->node_num; i++) {
		G->arr[i] = (Vnode*)calloc(1, sizeof(Vnode));
		G->arr[i]->data = vexs[i];
	}

	for (int i = 0; i < G->edge_num; i++) {
		c1 = edges[i][0];
		c2 = edges[i][1];

		p1 = find_position(c1, G, G->node_num);
		p2 = find_position(c2, G, G->node_num);

		Enode* node1 = (Enode*)calloc(1, sizeof(Enode));
		node1->ivex = p2;

		if (G->arr[p1]->first_edge == NULL) {
			G->arr[p1]->first_edge = node1;
		}
		else {
			link_last(G->arr[p1]->first_edge, node1);
		}
	}
	return G;
}
邻接表的存储结果

总的代码如下图所示
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define MAX_SIZE 40

typedef struct Enode {
	int ivex;
	struct Enode* next_edge;
}Enode;

typedef struct Vnode {
	int data;
	struct Enode* first_edge;
};

typedef struct PLgraph {
	int edge_num;
	int node_num;
	Vnode* arr[MAX_SIZE];
};

int find_position(char ch, PLgraph* G,int len) {
	for (int i = 0; i < len; i++) {
		if (ch == G->arr[i]->data) {
			return i;
		}
	}
	return -1;
}

//将节点连接到链表尾
void link_last(Enode* head, Enode* node) {
	while (head->next_edge) {
		head = head->next_edge;
	}
	head->next_edge = node;
	return;
}

PLgraph* store_undirected_graph() {
	char vexs[] = { 'A','B','C','D','E','F','G' };
	char edges[][2] = {
		{'A','C'},
		{'A','D'},
		{'A','F'},
		{'B','C'},
		{'C','D'},
		{'E','G'},
		{'F','G'}
	};

	int len1 = (sizeof(vexs) / sizeof(vexs[0]));
	int len2 = (sizeof(edges) / sizeof(edges[0]));

	char c1;
	char c2;

	int p1;
	int p2;

	Enode* node1;
	Enode* node2;

	PLgraph* G = (PLgraph*)calloc(1, sizeof(PLgraph));
	G->edge_num = len2;
	G->node_num = len1;

	//初始化邻接表中个顶点信息
	for (int i = 0; i < len1; i++) {
		G->arr[i] = (Vnode*)calloc(1, sizeof(Vnode));
		G->arr[i]->data = vexs[i];
		G->arr[i]->first_edge = NULL;
	}

	//初始化链表节点之间的关系
	for (int i = 0; i < len2; i++) {
		c1 = edges[i][0];
		c2 = edges[i][1];

		p1 = find_position(c1, G, len1);
		p2 = find_position(c2, G, len1);

		node1 = (Enode*)calloc(1, sizeof(Enode));
		node1->ivex = p1;

		node2 = (Enode*)calloc(1, sizeof(Enode));
		node2->ivex = p2;

		if (G->arr[p1]->first_edge == NULL) {
			G->arr[p1]->first_edge = node2;
		}
		else {
			link_last(G->arr[p1]->first_edge, node2);
		}
		
		if (G->arr[p2]->first_edge == NULL) {
			G->arr[p2]->first_edge = node1;
		}
		else {
			link_last(G->arr[p2]->first_edge, node1);
		}
	}
	return G;
}

PLgraph* store_directed_graph() {
	char vexs[] = { 'A','B','C','D','E','F','G' };
	char edges[][2] = {
		{'A','C'},
		{'A','D'},
		{'A','F'},
		{'B','C'},
		{'C','D'},
		{'E','G'},
		{'F','G'}
	};

	char c1;
	char c2;

	int p1;
	int p2;

	PLgraph* G = (PLgraph*)calloc(1, sizeof(PLgraph));
	G->edge_num = sizeof(edges) / sizeof(edges[0]);
	G->node_num = sizeof(vexs) / sizeof(vexs[0]);

	for (int i = 0; i < G->node_num; i++) {
		G->arr[i] = (Vnode*)calloc(1, sizeof(Vnode));
		G->arr[i]->data = vexs[i];
	}

	for (int i = 0; i < G->edge_num; i++) {
		c1 = edges[i][0];
		c2 = edges[i][1];

		p1 = find_position(c1, G, G->node_num);
		p2 = find_position(c2, G, G->node_num);

		Enode* node1 = (Enode*)calloc(1, sizeof(Enode));
		node1->ivex = p2;

		if (G->arr[p1]->first_edge == NULL) {
			G->arr[p1]->first_edge = node1;
		}
		else {
			link_last(G->arr[p1]->first_edge, node1);
		}
	}
	return G;
}


void DFS(int* visit, PLgraph* G, int i) {
	if (visit[i])return;
	visit[i] = 1;

	Enode* node = G->arr[i]->first_edge;
	printf("%c ", G->arr[i]->data);
	while (node) {
		if (!visit[node->ivex])
			DFS(visit, G, node->ivex);
		node = node->next_edge;
	}
	return ;
}

void DFS_traverse(PLgraph* G) {
	int visit[MAX_SIZE] = {};
	printf("DFS:\n");
	for (int i = 0; i < G->node_num; i++) {
		DFS(visit, G, i);
	}
	printf("\n");
	return;
}

void BFS(PLgraph* G) {
	int visit[MAX_SIZE] = {};
	int queue[MAX_SIZE] = {};
	int head = 0;
	int tail = 0;

	printf("BFS\n");
	for (int i = 0; i < G->node_num; i++) {
		if (visit[i] == 0) {
			printf("%c ", G->arr[i]->data);
			queue[tail++] = i;
			visit[i] = 1;
		}
		while (head != tail) {
			Enode* node = G->arr[queue[head++]]->first_edge;
			while (node) {
				if (visit[node->ivex] != 1) {
					visit[node->ivex] = 1;
					queue[tail++] = node->ivex;
					printf("%c ", G->arr[node->ivex]->data);
				}
				node = node->next_edge;
			}
		}
	}
	return;
}

void print_graph(PLgraph* G) {
	int len = G->node_num;
	for (int i = 0; i < len; i++) {
		Enode* head = G->arr[i]->first_edge;
		printf("%c(%d) ", G->arr[i]->data, i);
		while (head) {
			printf("%c(%d)", G->arr[head->ivex]->data, head->ivex);
			head = head->next_edge;
		}
		printf("\n");
	}
	return;
}

int main() {
	PLgraph* G = NULL;
	//G = store_undirected_graph();
	G = store_directed_graph();
	print_graph(G);
	DFS_traverse(G);
	BFS(G);
	return 0;
}

如果有什么描述错误的地方欢迎指正。

shaw chakong
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第七章：深度优先搜索
WANGHAOXIN364的博客
02-13 3834
不撞南墙不回头-深度优先搜索 广度优先搜索BFS是每次将当前状态能够一步拓展出的所有状态，全部拓展出来依次存入队列。而深度优先搜索是将当前状态按照一定的规则顺序，先拓展一步得到一个新状态，再对这个这个新状态递归拓展下去。如果无法拓展，则退回一步到上一步的状态，再按照原先设定的规则顺序重新寻找一个状态拓展。如此搜索，直到找到目标状态，或者遍历完所有的状态。 深度优先搜索 深度优先搜索（Depth First Search，DFS），简称深搜，其状态“退后一步”的顺序符合“后进先出”的特点，所以采用“..
广搜与深搜
雪雪
05-28 896
一、深搜 属于图算法的一种，英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次； 深度优先遍历图的思想是，从图中某顶点v出发： （1）访问顶点v； （2）依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问； （3）若此时图中尚有顶点未被访问，则从一个未被访问的顶点出...
Go 分布式学习利器（15） -- Go 实现 深搜和广搜
天行健，地势坤
11-29 357
强化语法，回顾算法。 通过Go语言实现 深度优先搜索 和 广度优先搜索，来查找社交网络中的三度好友关系（三度指的是一个节点到 其相邻节点 到 其相邻节点的节点 ，图递增三层好友关系）。 涉及到的Go语言语法： Go的封装特性 空接口和 断言 数组的切片特性 Go 实现的双向链表库 – container/list 实现基本的搜索算法：深搜和广搜 深度优先搜索 就是沿着一个方向一直走，如果发现最后的结果是失败的，回溯到上一步，继续尝试其他分支。 广度优先搜索 就是层次搜索，将从当前节点到下一节点所有的步
浅谈深搜广搜
qq_52332769的博客
05-06 2084
深搜广搜深度优先搜索 Depth First Search(DFS)简介：基本思想：回溯法：深搜优缺点优点缺点分析算法的实际实现流程：算法举例例一： 深度优先搜索 Depth First Search(DFS) 简介： 深度优先搜索所遵循的搜索策略是尽可能“深”地搜索树。 基本思想： 为了求得问题的解，会将每一结点所有可能路径都走一遍，先选择某一种可能情况向前（子结点）探索，在探索过程中，一旦发现原来的选择不符合要求，就回溯至父亲结点(可认为是上一结点)重新选择另一结点，继续向前探索，如此反复进行，直
搜索算法-深搜与广搜
qq_37448192的博客
01-12 1250
主要用于自己复习用的，专业性有待考量，想学的最好还是别点进来看。
有向图的创建及深搜广搜
吃橘子
12-05 669
文章目录输入输出有向图的创建深搜深搜的定义代码实现广搜广搜的定义广搜的原理代码实现 输入 第一行输入两个整数，以空格隔开，分别代表图的顶点数n和弧数e。(顶点个数<=20) 第二行依次输入顶点值，类型为字符，中间不用间隔符。 接下去有e行，每行为两个字符 uv（中间没有间隔符），表示一条弧<u,v>。 5 7 ABCDE AB AE BC CD DA DB EC 输出 第一行，输...
算法之深搜与广搜
爱技术的小白
06-09 1591
在经过7次算法课的学习后，自己的能力提升了很多，只不过对于学的知识很多都不是很懂，懂的中也有一些很不熟练，先将自己较为熟练的深搜与广搜做一个整理； 深度优先搜索（Depth-First-Search）其概念简要的说就是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次.该算法用到的事递归思想；递归需要两个部分：基线条件和递归条件； 我们从a出发，先到b,再到e,之后回去，到b,...
图的邻接矩阵存储与深搜广搜
cprimesplus的博客
05-14 316
存储结构   保存图的顶点名称，需要一个一维数组；保存顶点间的关系，需要一个二维数组；保存图的类型（有向图、无向图等）需要一个整形存储；另外，还需要明确图的顶点数与边数，方便创建等操作。 代码 #include<iostream> #include<cstring> #include<queue> #define INFINITY 0 using namespa...
深搜 vs 广搜
学IT的细胞膜的博客
03-19 214
深搜 vs 广搜
图的数据结构深搜/广搜
06-03
1. 图的类定义，可能包括节点和边的结构，以及图的存储方式（邻接矩阵或邻接表）。 2. DFS和BFS的实现，可能包含两个独立的函数，分别用于深度优先和广度优先遍历。 3. 测试用例，用于验证算法的正确性，可能包括有...
图的实现及深搜和广搜
05-17
在这个主题中，我们将深入探讨如何使用链式存储结构实现图，并详细解释深度优先搜索（DFS）和广度优先搜索（BFS）这两种图遍历算法。 首先，让我们了解**链式存储结构**。相比于顺序存储，链式存储允许我们在内存中...
邻接表实现图的广搜和深搜(java模板）
04-14
邻接表是一种空间效率高的图数据结构，它为每个顶点维护一个列表，列表中包含了所有与该顶点直接相连的其他顶点。相比于邻接矩阵，邻接表更适合处理稀疏图，因为不需要为不存在的边分配额外的空间。 **二、广度优先...
图的遍历（邻接矩阵、邻接链表建图，深搜、广搜遍历，生成最小生成树）
12-16
在这个课程设计中，我们将深入探讨“图的遍历”这一主题，它包括了如何使用邻接矩阵和邻接链表来构建图，以及如何通过深度优先搜索（DFS）和广度优先搜索（BFS）遍历图，最后还将学习Prim算法和Kruskal算法来生成...
图 拓扑排序 深度搜索 广度搜索 最小生成树
11-28
在这个主题中，我们将深入探讨“图”的核心概念，以及与之相关的拓扑排序、深度优先搜索（DFS）、广度优先搜索（BFS）和最小生成树（Minimum Spanning Tree, MST）。 首先，**图** 是由节点（也称为顶点）和边组成...
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 220
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
学懂C语言系列（三）：C语言基本语法
martian665的专栏
07-17 561
学懂C语言系列,C语言基本语法
C++笔试强训7
最新发布
m0_74189279的博客
07-21 513
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
c++ primer plus 第16章string 类和标准模板库, 16.3.2 可对矢量执行的操作
zhyjhacker的博客
07-21 714
c++ primer plus 第16章string 类和标准模板库, 16.3.2 可对矢量执行的操作。
邻接表的深搜广搜c语言
12-07
下面是邻接表的深搜和广搜的C语言实现： 1. 邻接表的深度优先搜索（DFS）C语言实现： ```c #define MAXNODE 1000 #define MAXSIDE 10000 typedef struct SIDE { int tailNode; int nextSide; int weight; } ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值