无向图的邻接表表示求度和两种遍历-----数据结构与算法笔记

已于 2022-01-27 22:24:16 修改
阅读量7.4k 收藏 129
点赞数 19
分类专栏： 数据结构与算法笔记 文章标签： 数据结构 算法
于 2022-01-27 22:23:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44847002/article/details/122613421
版权

📚 参考书：《数据结构（C语言）》–严蔚敏等编著，清华大学出版社。

📖 邻接表

💻 邻接表是图的一种链式存储结构，而邻接矩阵是图的一种顺序存储结构(数组)。
💻 在邻接表中，对图中每个顶点都建立一个单链表，在第i个单链表中的节点表示衣依附于顶点vi的边。
💻 每个节点由3个域组成，如下：
我在学习中为了方便把info权值信息的节点省略掉了：
在这里插入图片描述
👀 举例：如下：一个无向图(有向图的邻接表画法类似，会好画一点)
在这里插入图片描述

⭐️⭐️⭐️ 重点
    🌔 若无向图中有n个节点、e条边，则它的邻接表需要n个头结点和2e个表结点。
    🌔 无论有向图还是无向图，其邻接表不唯一，而邻接矩阵唯一。

🎈 图的邻接表的存储表示

#define MAX_VERTEX_NUM 20
typedef struct ArcNode {		//边/弧的节点结构
	int adjvex;		//该弧所指向的顶点的位置
	struct ArcNode *nextarc;	//指向下一条弧的指针
	InfoType *info;	//该弧的相关信息的指针
}ArcNode;

typedef struct VNode {			//顶点的节点结构
	VertexType data;	//顶点信息
	ArcNode *firstarc;	//指向第一条依附于该顶点的弧的指针
}VNode, AdjList[MAX_VERTEX_NUM];

typedef struct {
	AdjList vertices;	//一个一维数组，存放顶点
	int vexnum, arcnum;	//图的当前顶点数和弧数
	int kind;	//图的种类
}ALGraph;

🎈 而对于邻接表，无向图与有向图的表示各有各自的特点：

    🍵 有向图的邻接表表示的特点：
       ⭐️ (n,e)的图有n个头结点和e个弧结点。
       ⭐️ 顶点 vi 的出度为第i个链表的弧结点数。
       ⭐️ 求顶点的邻接点容易。
       ⭐️ 求顶点 vi 的入度不容易求出。
       ⭐️ 找出度容易，找入度难。

    🍵 无向图的邻接表表示的特点：
       🌔 (n,e)的图有n个头结点和2e个胡结点。
       🌔 顶点 vi 的度为第i个链表的边/弧结点数。
       🌔 求顶点的邻接点容易。

📖 邻接矩阵与邻接表的区别

🍍 对于任意确定的无向图，邻接矩阵表示唯一，而邻接表表示不唯一。
🍍 邻接矩阵空间复杂度为O(n2),而邻接表的空间复杂度为O(n+e)。
🍍 用途：邻接矩阵多用于稠密图，邻接表多用于稀疏图。

📖 图的遍历

使图的结点仅被访问一次，叫图的遍历，图的遍历包括深度优先搜索和广度优先搜索，对无向图和有向图都使用，本篇采取无向图的遍历举例。

🏠 深度优先搜索遍历 (DFS)

深度优先搜索遍历类似于树的先根遍历，当然，在选取所谓的 “根节点” 是随意从图中某个顶点出发的，当然在题中会给出指定的v。

🍺深度优先搜索的基本思想：
     🎈 访问指定的某个结点v，将v作为当前结点；
     🎈 访问当前结点的下一个未被访问过的邻接点(访问过的顶点就不Care了)，并以该邻接点作为当前结点；
     🎈 若遇到死角（无路可走），则沿着搜索路径回退，直到退到当前结点有未访问过的邻接点的顶点，继续访问；
     🎈 重复上3个步骤，直到所有和当前顶点有路径相通的顶点都访问过，就表示图的深度优先搜索遍历结束。

🌰 让我们来看个例子
如下无向图：
1️⃣ 将V1作为当前结点；
在这里插入图片描述

2️⃣ V1的邻接点有V1和V2，访问V1的邻接点V2（或者访问V3）；
在这里插入图片描述
3️⃣ 同样上步骤，如下图：
在这里插入图片描述
4️⃣ 当到V8时，遇到死角（无路可走了，V8没有未被访问过的邻接点了）的时候，进行回退，直到退到V1：
在这里插入图片描述
5️⃣ 这时候又从V1的另一个邻接点V3开始访问
在这里插入图片描述

显然无向图走遍了，所以此过程为一个递归的过程，要不断的判断进行回退操作，离不开递归的思想。然而此遍历是不唯一的，若是从v1 -> v3出发就该是如下样子：
在这里插入图片描述
当然在程序中深度优先搜索遍历又是一个样子，这是与代码写法有关。

⭐️ 算法的时间复杂度为：O(n+e)

🛠 深度优先搜索遍历代码：

Status DFS(ALGraph G,int v);
//深度优先遍历
Status DFS(ALGraph G,int v) {
    visited[v] = true;
    printf("V%d ",G.vertices[v].data);
    ArcNode *p;
    p=G.vertices[v].firstarc;
    while(p) {
        if(!visited[p->adjvex]) {
            DFS(G,p->adjvex);
        }
        p = p->nextarc;
    }
}

Status DFS_Traverse(ALGraph G);
Status DFS_Traverse(ALGraph G) {
    int i;
    for(i=0; i<G.vexnum; i++)
        visited[i] = false;
    printf("无向图的邻接表DFS(深度优先遍历)结果为：\n");
    for(i=0; i<G.vexnum; i++) {
        if(!visited[i])
            DFS(G,i);	//递归入口
    }
}

🏠 广度优先搜索遍历 (BFS)

广度优先搜索遍历类似于树的 “层次遍历”，与深度优先搜索遍历一样，从某个起点开始进行。

🍺广度优先搜索的基本思想：
     🎈 访问指定的某个结点v，将v作为当前结点；
     🎈 访问当前结点的所有未访问过的邻接点，按照这些顶点被访问的先后次序依次访问它们所有未访问过的邻接点；
     🎈 若此图中尚有未被访问过的顶点，则另选图中一个未被访问过的顶点作为当前起始点，重复上述步骤。

🌰 让我们来看个例子
采用上面的无向图：
1️⃣ 从V1出发访问它所有未访问过的邻接点
在这里插入图片描述
2️⃣ 先访问的是V3，根据次序，从V3开始访问：
在这里插入图片描述
3️⃣ 在这里发现V6和V7都没有未访问过的邻接点了，按照思想，从V2开始访问：
在这里插入图片描述
4️⃣ 依次从V5开始，V5 - V9 - V8（没有从V4开始访问了，因为从V5开始依次都有一个未访问过的顶点）
在这里插入图片描述

在使用广度优先搜索遍历算法时，需要借助循环辅助队列以存储已被访问过的顶点的标志。广度优先搜索算法中，每个顶点至多进一次队列，且广度优先搜索和深度优先搜索的时间复杂度都为：O(n+e)。

🛠 广度优先搜索遍历代码：

Status FirstAdjVex(ALGraph G,int u);
Status FirstAdjVex(ALGraph G,int u) {
    ArcNode *p;
    int v = LocateVex(G,G.vertices[u].data);
    p = G.vertices[v].firstarc;
    if(p)
        return p->adjvex;
    else
        return 0;
}

Status NextAdjVex(ALGraph G,int u,int w);
Status NextAdjVex(ALGraph G,int u,int w) {
    ArcNode *p;
    int v = LocateVex(G,G.vertices[u].data);
    if(u>=0 && u<G.vexnum && w>0 && w<G.vexnum) {
        p = G.vertices[v].firstarc;
        while(p->nextarc) {
            if(p->adjvex == w)
                return p->nextarc->adjvex;
            else
                p = p->nextarc;
        }
    }
    return 0;
}

Status BFS(ALGraph G,int v);
//广度优先遍历
Status BFS(ALGraph G,int v) {
    SqQueue Q;
    InitQueue(Q);
    printf("V%d ",G.vertices[v].data);
    EnQueue(Q,v);
    visited[v]=true;
    ArcNode *w;
    while(Q.front != Q.rear) {
        int u=0;
        DeQueue(Q,u);
        w = G.vertices[u].firstarc;
        while(w != NULL) {
            if(!visited[w->adjvex]) {
                printf("V%d ",G.vertices[w->adjvex].data);
                visited[w->adjvex] = true;
                EnQueue(Q,w->adjvex);
            }
            w = w->nextarc;
        }
    }
}

Status BFS_Traverse(ALGraph G);
Status BFS_Traverse(ALGraph G) {
    int i;
    for(i=0; i<G.vexnum; i++)
        visited[i] = false;
    printf("无向图的邻接表BFS(广度优先遍历)结果为：\n");
    for(i=0; i<G.vexnum; i++) {
        if(visited[i]==false)
            BFS(G,i);
    }
}

🛠 全码如下:

#include "stdio.h"
#include "stdlib.h"
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXQSIZE 100
#define MAX_VERTEX_NUM 20

int visited[MAX_VERTEX_NUM];    //访问标志数组

typedef int Status;
typedef int VertexType;
typedef struct {	//使用循环辅助队列
    VertexType *base;
    int front;
    int rear;
} SqQueue;

typedef struct ArcNode {
    int adjvex;     //该弧所指向的顶点的位置
    struct ArcNode  *nextarc;   //指向下一条弧的指针
} ArcNode;

typedef struct VNode {
    VertexType  data;   //顶点信息
    ArcNode *firstarc;  //指向第一条依附于该顶点的弧的指针
} VNode, AdjList[MAX_VERTEX_NUM];

typedef struct {
    AdjList vertices;
    int vexnum,arcnum;  //图当前顶点数和弧数
} ALGraph;

/*******************循环辅助队列************************/
Status InitQueue(SqQueue &Q);
Status InitQueue(SqQueue &Q) {
    Q.base = (VertexType *)malloc(MAXQSIZE*sizeof(VertexType));
    if(!Q.base) exit(OVERFLOW);
    Q.front = Q.rear = 0;
    return OK;
}

Status EnQueue(SqQueue &Q,VertexType e);
Status EnQueue(SqQueue &Q,VertexType e) {
    if((Q.rear + 1)%MAXQSIZE == Q.front) return ERROR;
    Q.base[Q.rear] = e;
    Q.rear = (Q.rear + 1)%MAXQSIZE;
    return OK;
}

Status DeQueue(SqQueue &Q,VertexType &e);
Status DeQueue(SqQueue &Q,VertexType &e) {
    if(Q.front == Q.rear) return ERROR;
    e = Q.base[Q.front];
    Q.front = (Q.front + 1)%MAXQSIZE;
    return OK;
}

Status QueueEmpty(SqQueue Q);
Status QueueEmpty(SqQueue Q) {
    if(Q.front == Q.rear) return TRUE;
    else return FALSE;
}
/*****************************************************/

Status LocateVex(ALGraph G,VertexType v);
//定位顶点v在图中的位置
Status LocateVex(ALGraph G,VertexType v) {
    int i;
    for(i=0; i<G.vexnum; i++) {
        if(G.vertices[i].data == v) return i;
    }
    return -1;
}

Status CreateUDG_AL(ALGraph &G);
//建立无向图的邻接表
Status CreateUDG_AL(ALGraph &G) {
    ArcNode *p1,*p2;
    int i,k,j,v1,v2;
    printf("请输入当前顶点数和弧数(空格隔开)：");
    scanf("%d %d",&G.vexnum,&G.arcnum);
    for(i=0; i<G.vexnum; ++i) {
        printf("请输入第%d个的顶点信息：",k+1);
        scanf("%d",&G.vertices[i].data);
        G.vertices[i].firstarc = NULL;
    }
    printf("\n");
    for(k=0; k<G.arcnum; ++k) {
        printf("请输入第%d条边的起点序号和终点序号(空格隔开)：",i+1);
        scanf("%d %d",&v1,&v2);
        i = LocateVex(G,v1);
        j = LocateVex(G,v2);

        p1 = new ArcNode;
        p1->adjvex = j;
        p1->nextarc = G.vertices[i].firstarc;
        G.vertices[i].firstarc = p1;

        p2 = new ArcNode;
        p2->adjvex = i;
        p2->nextarc = G.vertices[j].firstarc;
        G.vertices[j].firstarc = p2;
    }
    return OK;
}

/**************深度优先遍历*****************/
Status DFS(ALGraph G,int v);
//深度优先遍历
Status DFS(ALGraph G,int v) {
    visited[v] = true;
    printf("V%d ",G.vertices[v].data);
    ArcNode *p;
    p=G.vertices[v].firstarc;
    while(p) {
        if(!visited[p->adjvex]) {
            DFS(G,p->adjvex);
        }
        p = p->nextarc;
    }
}

Status DFS_Traverse(ALGraph G);
Status DFS_Traverse(ALGraph G) {
    int i;
    for(i=0; i<G.vexnum; i++)
        visited[i] = false;
    printf("无向图的邻接表DFS(深度优先遍历)结果为：\n");
    for(i=0; i<G.vexnum; i++) {
        if(!visited[i])
            DFS(G,i);
    }
}
/*******************************************/

/**************广度优先遍历*****************/
Status FirstAdjVex(ALGraph G,int u);
Status FirstAdjVex(ALGraph G,int u) {
    ArcNode *p;
    int v = LocateVex(G,G.vertices[u].data);
    p = G.vertices[v].firstarc;
    if(p)
        return p->adjvex;
    else
        return 0;
}

Status NextAdjVex(ALGraph G,int u,int w);
Status NextAdjVex(ALGraph G,int u,int w) {
    ArcNode *p;
    int v = LocateVex(G,G.vertices[u].data);
    if(u>=0 && u<G.vexnum && w>0 && w<G.vexnum) {
        p = G.vertices[v].firstarc;
        while(p->nextarc) {
            if(p->adjvex == w)
                return p->nextarc->adjvex;
            else
                p = p->nextarc;
        }
    }
    return 0;
}

Status BFS(ALGraph G,int v);
//广度优先遍历
Status BFS(ALGraph G,int v) {
    SqQueue Q;
    InitQueue(Q);
    printf("V%d ",G.vertices[v].data);
    EnQueue(Q,v);
    visited[v]=true;
    ArcNode *w;
    while(Q.front != Q.rear) {
        int u=0;
        DeQueue(Q,u);
        w = G.vertices[u].firstarc;
        while(w != NULL) {
            if(!visited[w->adjvex]) {
                printf("V%d ",G.vertices[w->adjvex].data);
                visited[w->adjvex] = true;
                EnQueue(Q,w->adjvex);
            }
            w = w->nextarc;
        }
    }
}

Status BFS_Traverse(ALGraph G);
Status BFS_Traverse(ALGraph G) {
    int i;
    for(i=0; i<G.vexnum; i++)
        visited[i] = false;
    printf("无向图的邻接表BFS(广度优先遍历)结果为：\n");
    for(i=0; i<G.vexnum; i++) {
        if(visited[i]==false)
            BFS(G,i);
    }
}
/*******************************************/

Status PrintUDG_AL(ALGraph G);
//打印图
Status PrintUDG_AL(ALGraph G) {
    int i;
    int a[G.vexnum];
    ArcNode *p;
    printf("\n无向图的邻接表顶点为：\n");
    for(i=0; i<G.vexnum; i++)
        printf("%d ",G.vertices[i].data);
    printf("\n无向图的邻接表为：\n");
    for(i=0; i<G.vexnum; i++) {
        printf("%d[V%d]-->",i,G.vertices[i].data);
        p = G.vertices[i].firstarc;
        int deg=0;  //记录度数
        while(p) {
            if(p->nextarc != NULL)
                printf("[%d]-->",p->adjvex);
            else {
                printf("[%d]-->NULL",p->adjvex);
            }
            deg++;
            p = p->nextarc;
        }
        a[i] = deg;
        printf("\n");
    }
    printf("\n");
    for(i=0; i<G.vexnum; i++) {
        printf("顶点%d的度为：%d\n",G.vertices[i].data,a[i]);
    }
    return OK;
}

int main(void) {
    ALGraph G;
    CreateUDG_AL(G);
    PrintUDG_AL(G);
    printf("\n");
    DFS_Traverse(G);
    printf("\n");
    BFS_Traverse(G);
    return 0;
}

实现：
在这里插入图片描述

🎓🎓🎓 感谢浏览，下篇见 👀

数据结构 | 第十六章：图 | 邻接矩阵 | 邻接链表 | 图的遍历【DFS】【BFS】
知识库搭建ing
01-14 794
《数据结构、算法与应用（C++语言描述）》第十六章：图，结合课程重点的自留笔记。
(王道408考研数据结构)第六章图-第二节1：图的存储结构（邻接矩阵、邻接表、十字链表和邻接多重表）
快乐江湖的博客
11-23 2325
文章目录一：邻接矩阵——适合存储稠密图（1）邻接矩阵定义（2）代码二：邻接表 一：邻接矩阵——适合存储稠密图 （1）邻接矩阵定义 图的邻接矩阵(Adjacency Matrix)：采用两个数组表示图。一个一维数组存储图中顶点信息；一个二维数组存储(邻接矩阵)图中边(无向图)或弧(有向图)的信息 对于无向图： 若某个元素值为1，代表两个顶点存在边 邻接矩阵是对称的，其中"1"的个数为图中总边数的2倍 矩阵中第iii行或第iii列元素之和为顶点iii的度 对于有向图： 若某个元素为1，代表从viv_{i
无向图的邻接表表示
10-15
无向图的邻接表表示
邻接表无向图--- C++
soledede
08-26 1802
邻接表无向图的介绍 邻接表无向图是指通过邻接表表示的无向图。 上面的图G1包含了"A,B,C,D,E,F,G"共7个顶点，而且包含了"(A,C),(A,D),(A,F),(B,C),(C,D),(E,G),(F,G)"共7条边。 上图右边的矩阵是G1在内存中的邻接表示意图。每一个顶点都包含一条链表，该链表记录了"该顶点的邻接点的序号"。例如，第2个顶点(顶点C)包含的链表所包含的节点的...
图数据结构详解：概念、实现与应用
最新发布
专注于人工智能领域的小何尚
03-31 1314
图(Graph)是一种非线性数据结构，由顶点(Vertex)和边(Edge)组成。直观地说，图是由点和连接这些点的线组成的。在数学上，图通常表示为G = (V, E)，其中V是顶点集合，E是边集合。社交网络中的人际关系城市之间的道路连接计算机网络中的连接关系分子结构中的原子连接任务之间的依赖关系图是一种非常强大和灵活的数据结构，它可以用来表示各种复杂的关系和网络。在本教程中，我们深入探讨了图的基本概念、表示方法、遍历算法以及一些重要的应用和高级主题。图的基本概念和术语。
无向图的邻接表
weixin_52634719的博客
12-29 3256
头结点里放当前顶点的值，以及它第一条弧的指针，表结点放邻接点的序号adjvex和指向下一边的指针 网的话，有权值，增加一个成员 无向图的邻接表，位置可互换，不唯一：边的顺序可以变 ...
无向图邻接表实现
热门推荐
菜菜的博客
04-21 1万+
无向图的邻接表的实现
无向图邻接表
flameboy的博客
05-06 1万+
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #define MAX_POINT_NUM 10 //最大顶点数 /* 图存储方法: 1.邻接矩阵(有向图) 2.邻接表 3.多重邻接表 3.十字交叉链表(有向图) */ //下面是无向图邻接表的实现的方法 //邻接节点类型 typedef struct arcnode { i...
数据结构与算法学习笔记十三--图
weixin_44501366的博客
04-29 493
1. 图的基本介绍 为什么要有图？(^ V ^?) 因为 线性表局限于一个直接前驱和一个直接后继的关系 树也只能有一个直接前驱也就是父节点 当我们需要表示多对多的关系时，这里我们就用到了图。 1.1 图的举例说明 图是一种数据结构，其中节点可以具有零个或多个相邻元素。两个节点之间的连接称为边。 1.2 图的常用概念 顶点（vertex） 边（edge） 路径 无向图（下图） 有向图（下图） 带权图（下图） 1.3 图的表示方法 图的表示方式有两种：二维数组表示（邻接矩阵）；链表表示（邻阶表）
C++数据结构与算法笔记之实验十 图的存储结构与遍历
weixin_45823430的博客
05-07 2441
实验十 图的存储结构与遍历 一、实验目的 1.掌握图的邻接矩阵表示方法； 2.理解基于邻接矩阵的深度优先、广度优先遍历方法的实现； 3.掌握图的邻接表表示方法； 4.理解基于邻接表的深度优先、广度优先遍历方法的实现。 二、实验环境 Windows 7以上版本的操作系统，Visual Studio 2019以上编程环境。 三、实验内容 1.画出以下无向图的邻接矩阵和邻接表，并对应邻接矩阵或邻接表列出该图的深度优先遍历序列和广度优先遍历序列。（选定A为起点进行遍历） 深度优先遍历序列：每次都是输出当前顶点的
软件设计师中级王勇老师课程笔记-5数据结构与算法基础
07-25
### 数据结构与算法基础 #### 一、绪论 数据结构是计算机科学中一个重要的概念，它涉及到数据的组织方式以及这些数据之间的关系。而算法则是解决特定问题的一系列指令或步骤。在软件开发过程中，良好的数据结构和...
无向图的邻接表构建和遍历
06-18
无向图的邻接表构建和两种遍历，存储表示，邻接表的创建，深度优先和广度优先遍历
23.无向图邻接表类
weixin_30413739的博客
03-27 107
namespace DSList{ //无向图邻接表类(Undirected Graph Adjacency List Class) public class GraphAdjList<T> : IGraph<T> { //Fields private ALVexNode<T>[] adjList; //Verte...
无向图的领接表
qq_32998153的博客
07-27 1271
无向图的领接表。 #include #include typedef struct EdgeNode{ // 边表结点 int adjvex; // 领接点域，存储该顶点对应的下标 struct EdgeNode *next; // 链域，指向下一个领接点 }EdgeNode; typedef struct Verte
建立无向图的邻接表
FreshHhand的博客
05-29 2617
P就是在图中的蓝色P，指向4的意思是：指向那一列数组的4号下标的元素 b站视频地址：https://www.bilibili.com/video/BV1nJ411V7bd?p=118 三个类的关系如下： G是ALGraph，V是VNode，A是ArcNode ** 完整代码如下： #include<iostream> using namespace std; typedef char VerTexType; #define MVNum 100 //Max Vertex N.
邻接表无向图
Geek
08-13 1308
邻接表无向图的介绍 邻接表无向图是指通过邻接表表示的无向图。 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;malloc.h&gt; #include &lt;string.h&gt; #define MAX 100 #define isLetter(a) ((((a)&gt;='a')&amp;&am...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

夏日的清晨

谢谢，只求点赞哟

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值