C语言-数据结构无向图深度优先遍历DFS（邻接表存储）

Happy鱿鱼

已于 2024-08-27 10:38:17 修改

阅读量168

点赞数 1

文章标签：深度优先 c语言数据结构

于 2024-08-27 10:19:39 首次发布

本文链接：https://blog.csdn.net/BamBoo_Bean/article/details/141586749

版权

在采用邻接表存储的无向图中使用DFS算法进行遍历，原理是在邻接表中依次访问顶点，如果顶点没有被访问就访问它，并标记为已访问，然后访问它的邻接结点，如果该邻接结点没有被访问就继续访问该邻接结点的下一个邻接结点，如果被访问过了，就回溯到上一个邻接结点，如果邻接结点也全部被访问完就回溯到下一个顶点进行进行同样的操作，直至全部结点访问完毕，就得出遍历结果了。思路和使用邻接矩阵的深度优先遍历一致，只是在代码实现改成链表的方式。

我们将创建这个图的邻接表深度优先遍历次序为ABCDEFGH，遍历序列情况也是不唯一的根据不同的邻接表来决定：

为了方便我就手动输入结点信息创建邻接表，创建邻接表的邻接结点的方式采用单链表中的头插法

邻接表顶点存储的结果：

深度优先遍历核心算法：

完整代码（包括：邻接表的实现、深度优先遍历）

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

#define MAXVEX 8    // 最大顶点数
#define TRUE 1 
#define FALSE 0

typedef char VertexType;  // 顶点类型，使用字符表示
typedef int EdgeType;     // 边上的权值类型，使用整数表示
typedef int Boolean;      // 布尔类型

Boolean visited[MAXVEX];  // 用于记录顶点的访问状态

// 边表结点
typedef struct EdgeNode {
    int adjvex;         // 顶点下标，表示该边的终点
    EdgeType info;      // 边上的权值
    struct EdgeNode* next;  // 指向下一条边的指针
} EdgeNode;

// 顶点结点
typedef struct VertexNode {
    VertexType data;     // 顶点数据
    EdgeNode* first;     // 指向该顶点的第一条边
} VertexNode, AdjList[MAXVEX];

// 图的邻接表表示
typedef struct {
    AdjList adjList;    // 顶点数组
    int numNodes;       // 图的顶点数
    int numEdges;       // 图的边数
} GraphAdjList;

void CreateALGraph(GraphAdjList* G) {
    int i, j;
    EdgeNode* e = NULL;
    char str[] = "ABCDEFGH"; // 顶点数据

    // 初始化邻接表
    for (i = 0; i < G->numNodes; i++) {
        G->adjList[i].data = str[i]; // 设置顶点数据
        G->adjList[i].first = NULL;  // 边表初始化为空
    }

    // 添加边 A->F
    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 5; // 邻接顶点序号为F
    e->next = G->adjList[0].first; // 插入到邻接表的第一个位置
    G->adjList[0].first = e;

    // 添加边 A->B->F
    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 1; // 邻接顶点序号为B
    e->next = G->adjList[0].first;
    G->adjList[0].first = e;

    // 添加边 B->A->C->G
    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 6; // 邻接顶点序号为G
    e->next = G->adjList[1].first;
    G->adjList[1].first = e;

    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 2; // 邻接顶点序号为C
    e->next = G->adjList[1].first;
    G->adjList[1].first = e;

    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 0; // 邻接顶点序号为A
    e->next = G->adjList[1].first;
    G->adjList[1].first = e;

    // 添加边 C->B->D
    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 3; // 邻接顶点序号为D
    e->next = G->adjList[2].first;
    G->adjList[2].first = e;

    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 1; // 邻接顶点序号为B
    e->next = G->adjList[2].first;
    G->adjList[2].first = e;

    // 添加边 D->C->H
    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 7; // 邻接顶点序号为H
    e->next = G->adjList[3].first;
    G->adjList[3].first = e;

    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 2; // 邻接顶点序号为C
    e->next = G->adjList[3].first;
    G->adjList[3].first = e;

    // 添加边 E->F->H
    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 7; // 邻接顶点序号为H
    e->next = G->adjList[4].first;
    G->adjList[4].first = e;

    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 5; // 邻接顶点序号为F
    e->next = G->adjList[4].first;
    G->adjList[4].first = e;

    // 添加边 F->A->E->G
    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 6; // 邻接顶点序号为G
    e->next = G->adjList[5].first;
    G->adjList[5].first = e;

    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 4; // 邻接顶点序号为E
    e->next = G->adjList[5].first;
    G->adjList[5].first = e;

    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 0; // 邻接顶点序号为A
    e->next = G->adjList[5].first;
    G->adjList[5].first = e;

    // 添加边 G->B->F->H
    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 7; // 邻接顶点序号为H
    e->next = G->adjList[6].first;
    G->adjList[6].first = e;

    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 5; // 邻接顶点序号为F
    e->next = G->adjList[6].first;
    G->adjList[6].first = e;

    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 1; // 邻接顶点序号为B
    e->next = G->adjList[6].first;
    G->adjList[6].first = e;

    // 添加边 H->D->E->G
    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 6; // 邻接顶点序号为G
    e->next = G->adjList[7].first;
    G->adjList[7].first = e;

    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 4; // 邻接顶点序号为E
    e->next = G->adjList[7].first;
    G->adjList[7].first = e;

    e = (EdgeNode*)malloc(sizeof(EdgeNode));
    e->adjvex = 3; // 邻接顶点序号为D
    e->next = G->adjList[7].first;
    G->adjList[7].first = e;

    // 打印邻接表（字母）
    EdgeNode* p = NULL;
    printf("边结点按邻接顶点字母打印:\n");
    for (i = 0; i < G->numNodes; i++) {
        printf("%c", G->adjList[i].data);
        p = G->adjList[i].first;
        while (p != NULL) {
            printf("->%c", G->adjList[p->adjvex].data); // 打印邻接顶点字母
            p = p->next;
        }
        printf("\n");
    }

    // 打印邻接表（下标）
    printf("\n边结点按邻接下标打印:\n");
    for (i = 0; i < G->numNodes; i++) {
        printf("%c", G->adjList[i].data);
        p = G->adjList[i].first;
        while (p != NULL) {
            printf("->%d", p->adjvex); // 打印邻接顶点下标
            p = p->next;
        }
        printf("\n");
    }
}

// 深度优先遍历
void DFS(GraphAdjList G, int i) {
    EdgeNode* p;
    visited[i] = TRUE;           // 标记顶点i为已访问
    printf("%c", G.adjList[i].data); // 输出顶点数据
    p = G.adjList[i].first;     // 获取顶点i的第一条边
    while (p) {
        if (!visited[p->adjvex]) { // 如果边的终点未被访问
            DFS(G, p->adjvex);    // 递归访问该顶点
        }
        p = p->next;             // 访问下一条边
    }
}

// 深度优先遍历图
void DFSTraverse(GraphAdjList G) {
    int i;
    for (i = 0; i < G.numNodes; i++) {
        visited[i] = FALSE;     // 初始化所有顶点为未访问状态
    }
    printf("\n深度优先遍历的结果为(DFS):\n");
    for (i = 0; i < G.numNodes; i++) {
        if (!visited[i]) {      // 如果顶点i未被访问
            DFS(G, i);         // 从顶点i开始深度优先遍历
        }
    }
    printf("\n");
}

int main() {
    GraphAdjList G;
    G.numNodes = MAXVEX;        // 设置顶点数
    CreateALGraph(&G);
    DFSTraverse(G);            // 进行深度优先遍历
    return 0;
}

运行结果：