数据结构_深度优先搜索(C语言)

数据结构总目录

深度优先搜索

1. 图文解析

深度优先搜索(Depth First Search，DFS)，是图结构的一种遍历算法。

深度优先搜索的遍历过程如下：

1. 选择起始顶点进行访问（假设从顶点A出发）
2. 在刚访问过的顶点《A》的相邻顶点中《B、E》，找出第一个未被访问的顶点《E》，并访问该顶点《E》
3. 以顶点《E》为新的起始顶点，递归重复（1）（2）步骤。

例如：当访问到顶点《E》时，由于顶点《E》没有相邻的顶点，递归程序会回退到顶点《A》继续查找未被访问的相邻顶点，从而访问到顶点《B》。

2. 源代码

#include<stdio.h>
#include<stdlib.h>
#define MaxVex 20

typedef int EdgeType;
typedef char VertexType;

typedef struct EdgeNode
{
    int adjvex;         
    EdgeType edgeData;  
    struct EdgeNode *next;
}EdgeNode, *EdgeList;

typedef struct
{
    VertexType vextexData; 
    EdgeList edgeList;       
}VertexNode, *VertexList;

// 邻接表结构
typedef struct
{
    VertexList vertexList; 
    int numVertexs, numEdges;     
}ALGraph;

void InitALGraph(ALGraph *G)
{

    G->numVertexs = 0;
    G->numEdges = 0;
    G->vertexList = (VertexNode *)malloc(MaxVex * sizeof(VertexNode));

    int i;
    for (i = 0; i < MaxVex; i++)
    {   
        G->vertexList[i].edgeList = (EdgeNode *)malloc(sizeof(EdgeNode));
        G->vertexList[i].edgeList->next = NULL;
    }
    printf("已初始化邻接表\n\n");
}

void CreateALGraph(ALGraph *G)
{
    printf("请输入顶点数和边数:");
    scanf("%d %d", &G->numVertexs, &G->numEdges);
    
    int i, j, k;
    EdgeType w;
    // 输入顶点数据
    for (i = 0; i < G->numVertexs; i++)
    {
        fflush(stdin);
        printf("请输入第%d个顶点数据:", i + 1);
        scanf("%c", &G->vertexList[i].vextexData);
    }
    // 输入边的权值
    for (k = 0; k < G->numEdges; k++)
    {
        printf("请输入边(vi, vj)上的顶点序号及权值:");
        scanf("%d %d %d", &i, &j, &w);

        EdgeNode *p1, *p2;
        p1 = (EdgeNode *)malloc(sizeof(EdgeNode));
        p2 = (EdgeNode *)malloc(sizeof(EdgeNode));

        // 链表头插法 插入 顶点（vi -> vj）的边
        p1->edgeData = w;
        p1->next = G->vertexList[i - 1].edgeList->next;
        G->vertexList[i - 1].edgeList->next = p1;
        p1->adjvex = j - 1; 
        
        // 对于无向图，同时还需要插入顶点（vj -> vi）的边
        p2->edgeData = w;
        p2->next = G->vertexList[j - 1].edgeList->next;
        G->vertexList[j - 1].edgeList->next = p2;
        p2->adjvex = i - 1;     
    }
    printf("已创建邻接表!\n\n");
}

// 深度优先搜索
void DFS(ALGraph G, int *visited, int v)
{
    printf("%c ", G.vertexList[v].vextexData);
    // 设置该顶点已被访问
    visited[v] = 1;
    EdgeNode *p = G.vertexList[v].edgeList;
    // 遍历该顶点的所有相邻顶点
    while (p->next)
    {
        p = p->next;
        if (!visited[p->adjvex])
        {
            // 若该相邻顶点未被访问, 则递归访问该顶点
            DFS(G, visited, p->adjvex);
        }
    }
}

void DFSTraverse(ALGraph G)
{
    int i, *visited;
    // 创建一个数组用于记录顶点的访问状态
    visited = (int *)malloc(G.numVertexs * sizeof(int));
    // 初始化数组, 即设置所有顶点初始状态为 未访问状态
    for (i = 0; i < G.numVertexs; i++)
    {
        visited[i] = 0;
    }
    printf("深度优先遍历:");
    for (i = 0; i < G.numVertexs; i++)
    {
        if (!visited[i])
        {
            DFS(G, visited, i);
        }
    }
    free(visited);
    printf("\n");
}

int main()
{
    ALGraph G;
    InitALGraph(&G);
    CreateALGraph(&G);
    DFSTraverse(G);
    system("pause");
    return 0;
}

3. 测试结果