图——邻接矩阵和邻接表存储的图的遍历的时间复杂度

最新推荐文章于 2024-06-01 01:04:56 发布
最新推荐文章于 2024-06-01 01:04:56 发布
阅读量3.3w 收藏 64
点赞数 22
分类专栏： 数据结构 文章标签： 邻接矩阵和邻接表存储的图的遍历的时间复杂度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fu_jian_ping/article/details/89300415
版权

用邻接矩阵构造图时，若存储的是一个无向图，则时间复杂度为O(n^2 + n*e)，其中，对邻接矩阵的初始化耗费的时间为O(n^2);

 

对于DFS,BFS遍历来说，时间复杂度和存储结构有关：

n表示有n个顶点，e表示有e条边。

1.若采用邻接矩阵存储，

时间复杂度为O(n^2);

 

 

2.若采用邻接链表存储，建立邻接表或逆邻接表时，

若输入的顶点信息即为顶点的编号，则时间复杂度为O(n+e);

若输入的顶点信息不是顶点的编号，需要通过查找才能得到顶点在图中的位置，则时间复杂度为O(n*e);

 

 

傅华涛Fu
关注
  • 22
    点赞
  • 踩
  • 64
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
图的邻接矩阵和邻接表实现
11-26
本文将详细探讨图的两种常见存储方式——邻接矩阵和邻接表，以及基于这两种数据结构的深度搜索（DFS）、广度搜索（BFS）和Dijkstra最短路径算法。 首先，邻接矩阵是一种二维数组，用于表示图中所有节点之间的连接...
算法时间复杂度（图）
05-21
所有算法时间复杂度对比、图表形式、函数关系
邻接矩阵和邻接表的时间复杂度
最新发布
la1466128339的博客
06-01 436
*空间复杂度**：但这个方法空间上更节省，因为如果你班上每个人都只有几个朋友，用信封这种形式记录大家的朋友关系，只占据很小的空间。但如果班上有非常多的同学们，而且大多数同学的朋友不多，那么每个同学有他们的朋友名单，这样的邻接表就更适合了。如果班上的同学不多，比如就几十个，而且彼此间的交友情况很复杂，那么使用一个大表格，也就是邻接矩阵，就比较合适了。因为朋友关系复杂，快速找到谁是谁的朋友更重要。**时间复杂度**：如果你想查所有小红的朋友，你需要看看她的信封里面都装了谁的名字，就得看一会儿才能找全。
软考考点之图的遍历时间复杂度
guangod的博客
09-27 6343
不做题，一些重要的解题思路及忽略的知识点就不会被总结。－－－2019－9－27于济南 图的遍历是指从图中的任一顶点出发，对图中的所有顶点访问一次且只访问一次。 如2016年上半年 第61题:以下关于图的遍历的叙述中,正确的是(61)。 A. 图的遍历是从给定的源点出发对每一个顶点仅访问一次的过程 B. 图的深度优先遍历方法不适用于无向图 C. 使用队列对图进行广度优先遍历 D. 图中有回路时...
邻接表遍历的时间复杂度
liuxiaocs7的博客
04-06 1万+
如果是无向图，则遍历时先访问顶点数组的各个元素，再访问其对应的边链表，由于有NNN个节点，而且无向图的EEE条边在边链表中会出现两次共为2E2E2E次，故一共的访问次数为N+2EN+2EN+2E 如果是有向图，则其EEE条边在边链表中不会出现两次(因为此时边链表值代表出度或者入度)，共总共的访问次数为N+EN+EN+E次，故时间复杂性为O(N+E)O(N+E)O(N+E) ...
邻接矩阵和邻接表
热门推荐
ZER00000001的博客
06-14 1万+
图的概述和存储结构（一）有一种说法是程序是由数据结构和算法组成的，这很能体现出数据结构在编码中的重要性。而代码优化的能力也是区别有基础的程序员和码农的重要标准，所以对于这一块的学习一定要稳重与细致，每一个章节都要实打实敲出能够实现该种结构的代码才算完成。数据结构的学习本质上是让我们能见到很多前辈在解决一些要求时间和空间的难点问题上设计出的一系列解决方法，我们可以在今后借鉴这些方法，也可以根据这些方法在遇到具体的新问题时提出自己的解决方法。（所以各种定义等字眼就不用过度深究啦，每个人的表达方式不一样而已）在此
【数据结构与算法】图——邻接表与邻接矩阵
qq_66314292的博客
05-04 1万+
邻接表与邻接矩阵
数据结构和常用排序算法复杂度
拉依达不拉跨的博客
11-24 7359
数据结构和常用排序算法复杂度
第六章 图（一）
Memorise1999的博客
04-01 1713
回顾 6.1图的定义和基本术语 完全图：任意两个点都有一条边相连 稀疏图：有很少边或弧的图 稠密图：有较多边或弧的图 网：边/弧带权的图 邻接：有边/弧相连的两个顶点之间的关系 注：（离散数学）中”（边）“表示两者没有先后顺序，“<弧>”表示两者存在前后关系 关联（依附）：边/弧与顶点之间的关系 顶点的度：与该顶点相关联的边的数目 例题 路径：接续的边构成的顶点序列 路径长度：路径上边或弧的数目/权值之和 回路（环）：第一个顶点和最后一个顶点相同的路径 简...
数据结构学习笔记——图的存储结构（邻接矩阵、邻接表、邻接多重表和十字链表）
小宇y的博客
08-14 1万+
图的常用存储结构有邻接矩阵和邻接表，另外还有十字链表、邻接多重表等等。//图的顶点数目、图的边数目 char V [ MAXSIZE ];//一维数组，存储顶点 int E [ MAXSIZE ] [ MAXSIZE ];//二维数组，边的邻接矩阵 } Graph;100//图的顶点数目、图的边数目 char V [ MAXSIZE ];//一维数组，存储顶点 int E [ MAXSIZE ] [ MAXSIZE ];//二维数组，边的邻接矩阵 } Graph;.........
数据结构学习--图的邻接矩阵和邻接表存储
06-25
图的存储方式主要有两种：邻接矩阵和邻接表。这两种存储方式各有优缺点，适用于不同的场景。 邻接矩阵是一种二维数组，其中的元素表示图中顶点之间的边。对于无向图，邻接矩阵是对称的，即如果顶点i和顶点j之间有一...
图的邻接矩阵和邻接表表示的各种算法
11-05
- 邻接表的空间效率更高，但查询是否存在边的时间复杂度略高，需要遍历链表。 3. **迪杰斯特拉算法**： - 迪杰斯特拉算法用于找到图中源节点到其他所有节点的最短路径。它可以处理带权重的有向或无向图。算法的...
图的邻接矩阵存储和邻接表存储
05-14
邻接表在空间效率上优于邻接矩阵，尤其适合稀疏图，但查找边的存在需要遍历列表，时间复杂度为O(V+E)。 在实际应用中，需要根据图的特性和需求来选择合适的存储结构。例如，如果图的边非常多，邻接表可能是更好的...
邻接矩阵存储方式实现_邻接表_邻接矩阵_数据结构_
09-29
其中，邻接矩阵和邻接表是两种常见的图存储方式。 **邻接矩阵** 邻接矩阵是一种二维数组，用于存储图中节点之间的连接关系。对于无向图，邻接矩阵是对称的，即矩阵的第i行第j列元素与第j行第i列元素相等，表示节点...
数据结构（八）：邻接表与邻接矩阵
weixin_34273046的博客
10-17 1795
邻接表和邻接矩阵是图的两种常用存储表示方式，用于记录图中任意两个顶点之间的连通关系，包括权值。 对于图 而言，其中 表示顶点集合， 表示边集合。 对于无向图 graph，图的顶点集合和边集合如下： graph 对于有向图 digraph，图的顶点集合和边集合如下： ...
图的存储方式——邻接矩阵和邻接表
syh的技术记录
05-18 6463
目录1. 基本概念2. 图的存储方式2.1 邻接矩阵2.2 邻接表3.两种方式的比较 1. 基本概念 1.什么是图？ 图由顶点和边组成，表示为G（V,E），其中G表示一个图，V是图G中顶点的集合，E是图G中边的集合。根据边是否有方向，可分为有向图和无向图。 2. 邻接点 两结点之间通过边相连，则互为邻接点。如在上面的无向图中，（1，3），（2，5）等都为邻接点。 3. 顶点的度 顶点的度指的是与顶点v相连的边的数目。对于无向图来讲，只有度的概念，而对于有向图来讲，可分为入度和出度。入度是指向该
图——图的存储结构之邻接矩阵、邻接表，十字链表，邻接多重表
l218623的博客
02-16 3658
图的逻辑结构：多对多。 图的存储结构： 图没有顺序存储结构，但可以借助二维数组来表示元素之间的关系 数组表示法（邻接矩阵）： 无向图的邻接矩阵： 例： 共有5个顶点，所以形成5*5的方阵。 举个例子，比如第一行： v1与v1本身之间无边，无邻接关系，所以为0 v1与v2之间有边，有邻接关系，所以为1 v1与v3之间无边，无邻接关系，所以为0 v1与v4之间有边...
邻接表/邻接矩阵
算法改变人生
03-18 3683
邻接表 一、邻接表 邻接表是图的一种链式存储结构。 邻接表中，对图中每个顶点建立一个单链表，第i个单链表中的结点表示依附于顶点Vi的边（对有向图是以顶点Vi为尾的弧）。 二、无向图的邻接表 三、有向图的邻接表和逆邻接表 （一）在有向图的邻接表中，第i个单链表链接的边都是顶点i发出的边。 （二）为了求第i个顶点的入度，需要遍历整个邻接表。因此
c语言编程：用邻接表和邻接矩阵实现图的广度遍历和深度遍历
09-18
### 回答1： 以下是使用邻接表和邻接矩阵实现图的广度遍历和深度遍历的C语言代码示例。 邻接表实现： ```c #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define MAX_VERTEX_NUM 100 // 最大顶点数 // 边结点 typedef struct EdgeNode { int adjvex; // 邻接点的下标 struct EdgeNode* next; // 指向下一个邻接点的指针 } EdgeNode; // 顶点结点 typedef struct VertexNode { int data; // 顶点数据 EdgeNode* firstedge; // 指向第一个邻接点的指针 } VertexNode, AdjList[MAX_VERTEX_NUM]; // 邻接表 typedef struct { AdjList vertices; // 顶点数组 int vexnum, edgenum; // 顶点数和边数 } ALGraph; // 初始化邻接表 void InitALGraph(ALGraph* G) { printf("请输入顶点数和边数："); scanf("%d%d", &G->vexnum, &G->edgenum); printf("请输入%d个顶点的数据：", G->vexnum); for (int i = 0; i < G->vexnum; i++) { scanf("%d", &G->vertices[i].data); G->vertices[i].firstedge = NULL; } printf("请输入%d条边的信息：\n", G->edgenum); for (int k = 0; k < G->edgenum; k++) { int i, j; printf("请输入第%d条边的两个顶点下标：", k + 1); scanf("%d%d", &i, &j); // 创建新结点 EdgeNode* e = (EdgeNode*)malloc(sizeof(EdgeNode)); e->adjvex = j; e->next = G->vertices[i].firstedge; G->vertices[i].firstedge = e; // 无向图还要创建一条反向边 e = (EdgeNode*)malloc(sizeof(EdgeNode)); e->adjvex = i; e->next = G->vertices[j].firstedge; G->vertices[j].firstedge = e; } } // 广度优先遍历 void BFS(ALGraph* G, int v) { bool visited[MAX_VERTEX_NUM] = { false }; // 初始化所有顶点为未访问 int queue[MAX_VERTEX_NUM], front = 0, rear = 0; visited[v] = true; queue[rear++] = v; printf("BFS: "); while (front < rear) { int i = queue[front++]; printf("%d ", G->vertices[i].data); EdgeNode* e = G->vertices[i].firstedge; while (e != NULL) { int j = e->adjvex; if (!visited[j]) { visited[j] = true; queue[rear++] = j; } e = e->next; } } printf("\n"); } // 深度优先遍历（递归版） void DFS(ALGraph* G, int v, bool visited[]) { visited[v] = true; printf("%d ", G->vertices[v].data); EdgeNode* e = G->vertices[v].firstedge; while (e != NULL) { int j = e->adjvex; if (!visited[j]) { DFS(G, j, visited); } e = e->next; } } // 深度优先遍历（非递归版） void DFS2(ALGraph* G, int v) { bool visited[MAX_VERTEX_NUM] = { false }; int stack[MAX_VERTEX_NUM], top = 0; visited[v] = true; stack[top++] = v; printf("DFS: "); while (top > 0) { int i = stack[--top]; printf("%d ", G->vertices[i].data); EdgeNode* e = G->vertices[i].firstedge; while (e != NULL) { int j = e->adjvex; if (!visited[j]) { visited[j] = true; stack[top++] = j; } e = e->next; } } printf("\n"); } int main() { ALGraph G; InitALGraph(&G); BFS(&G, 0); bool visited[MAX_VERTEX_NUM] = { false }; DFS(&G, 0, visited); printf("\n"); DFS2(&G, 0); return 0; } ``` 邻接矩阵实现： ```c #include <stdio.h> #include <stdbool.h> #define MAX_VERTEX_NUM 100 // 最大顶点数 // 邻接矩阵 typedef struct { int edges[MAX_VERTEX_NUM][MAX_VERTEX_NUM]; // 二维数组表示边 int vexnum, edgenum; // 顶点数和边数 } MGraph; // 初始化邻接矩阵 void InitMGraph(MGraph* G) { printf("请输入顶点数和边数："); scanf("%d%d", &G->vexnum, &G->edgenum); printf("请输入%d个顶点的数据：", G->vexnum); for (int i = 0; i < G->vexnum; i++) { for (int j = 0; j < G->vexnum; j++) { G->edges[i][j] = 0; // 初始化所有边为0 } } for (int i = 0; i < G->vexnum; i++) { int data; scanf("%d", &data); } printf("请输入%d条边的信息：\n", G->edgenum); for (int k = 0; k < G->edgenum; k++) { int i, j; printf("请输入第%d条边的两个顶点下标：", k + 1); scanf("%d%d", &i, &j); G->edges[i][j] = G->edges[j][i] = 1; // 无向图需要将两个方向的边都设置为1 } } // 广度优先遍历 void BFS(MGraph* G, int v) { bool visited[MAX_VERTEX_NUM] = { false }; // 初始化所有顶点为未访问 int queue[MAX_VERTEX_NUM], front = 0, rear = 0; visited[v] = true; queue[rear++] = v; printf("BFS: "); while (front < rear) { int i = queue[front++]; printf("%d ", i); for (int j = 0; j < G->vexnum; j++) { if (G->edges[i][j] == 1 && !visited[j]) { visited[j] = true; queue[rear++] = j; } } } printf("\n"); } // 深度优先遍历 void DFS(MGraph* G, int v, bool visited[]) { visited[v] = true; printf("%d ", v); for (int j = 0; j < G->vexnum; j++) { if (G->edges[v][j] == 1 && !visited[j]) { DFS(G, j, visited); } } } int main() { MGraph G; InitMGraph(&G); BFS(&G, 0); bool visited[MAX_VERTEX_NUM] = { false }; DFS(&G, 0, visited); printf("\n"); return 0; } ``` ### 回答2： 邻接表和邻接矩阵是两种常见的图的表示方法，可以用于实现图的广度遍历和深度遍历的算法。 邻接表是一种链表的形式，用于表示图的结构。对于每个顶点，将其邻接的顶点用链表链接起来，形成一个邻接表。邻接矩阵则是一个二维矩阵，用于表示图的连接关系。 广度遍历（BFS）是从图的某个节点出发，先访问其所有邻接节点，再按照广度优先的顺序遍历所有未被访问的邻接节点。具体实现方法如下： 1. 创建一个队列，将起始节点入队。 2. 从队列中取出一个节点，访问该节点并标记为已访问。 3. 遍历该节点的邻接节点，将未被访问的节点入队。 4. 重复步骤2和3，直到队列为空。 深度遍历（DFS）是从图的某个节点出发，先访问其一个邻接节点，再依次访问该节点的邻接节点，直到无法继续访问为止，然后回溯到上一个节点，继续访问下一个未被访问的邻接节点。具体实现方法如下： 1. 创建一个栈，将起始节点压栈。 2. 从栈中弹出一个节点，访问该节点并标记为已访问。 3. 遍历该节点的邻接节点，将未被访问的节点压栈。 4. 重复步骤2和3，直到栈为空。 无论使用邻接表还是邻接矩阵都可以实现图的广度遍历和深度遍历。对于邻接表，广度遍历可以通过链表的特性实现邻居节点的访问顺序；深度遍历可以通过递归或者栈的方式实现节点的回溯。对于邻接矩阵，广度遍历可以通过遍历矩阵的行实现邻居节点的访问顺序；深度遍历可以通过递归或者栈的方式实现节点的回溯。 综上所述，无论使用邻接表还是邻接矩阵，我们都可以实现图的广度遍历和深度遍历的算法。 ### 回答3： 邻接表和邻接矩阵是两种常用的存储图的方法，它们可以用于实现图的广度遍历和深度遍历。 邻接表是一种链表的数据结构，用于表示图中各个顶点之间的关系。对于每个顶点，邻接表中存储了与之相邻顶点的指针。通过邻接表实现图的广度遍历时，可以使用队列来存储待访问的顶点。首先将起始顶点放入队列中，然后依次访问队列中的顶点，并将其未访问过的相邻顶点放入队列中。直到队列为空时，广度遍历结束。 邻接矩阵是一个二维数组，用于表示图中各个顶点之间的关系。对于顶点i和顶点j，邻接矩阵中的元素A[i][j]表示它们之间的边。通过邻接矩阵实现图的深度遍历时，可以使用递归或栈来存储待访问的顶点。首先将起始顶点放入栈中，然后依次访问栈顶的顶点，并将其未访问过的相邻顶点放入栈中。直到栈为空时，深度遍历结束。 无论使用邻接表还是邻接矩阵，图的广度遍历和深度遍历的时间复杂度都是O(V+E)，其中V为顶点数，E为边数。 邻接表的优点是可以节省空间，适用于稀疏图。而邻接矩阵的优点是查找两个顶点之间是否有边的时间复杂度为O(1)，适用于稠密图。选择哪种方法实现图的广度遍历和深度遍历取决于具体问题的要求和图的类型。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值