图的相关操作-深度/广度优先遍历（邻接表存储）

深度/广度优先遍历（邻接表表示）

一：邻接表的存储结构

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

typedef struct{
    int data;        //顶点数据
    struct ArcNode* firstarc;    //指向第一条边的指针
}VNode;

typedef struct {
    VNode adjlist[20];  //邻接表
    int arcnum;         //边数
    int vexnum;         //顶点数
}AGraph;

二：深度优先遍历（邻接表）

int visted[100];

void DFS(AGraph G,int v){
    printf("%d",G.adjlist[v].data);     //访问
    visted[v] = 1;                              //表示该顶点已经访问完了
    ArcNode* p;                                 //辅助指针
    p = G.adjlist[v].firstarc;
    while (p!=NULL){
        if (visted[p->adjvex]==0){
            DFS(G,p->adjvex);
        }
        p = p->next;
    }
}

void DFSTraverse(AGraph G){
    //初始化辅助数组
    for (int i = 0; i < G.vexnum; ++i) {
        visted[i] = 0;
    }
    for (int i = 0; i < G.vexnum; ++i) {
        if (visted[i]==0){
            DFS(G,i);
        }
    }
}

三：广度优先遍历（邻接表）

//广度优先遍历
void BFS(AGraph G,int v){
    printf("%d",G.adjlist[v].data);
    visted[v] = 1;
    ArcNode* p;         //辅助指针
    int j;
    int queue[20];      //队列的简便写法
    int front =-1,rear = -1;
    rear = (rear+1)%20;
    queue[rear] = v;
    while (front!=rear){
        front = (front+1)%20;
        j = queue[front];
        p = G.adjlist[j].firstarc;
        while (p!=NULL){
            if (visted[p->adjvex]==0){
                printf("%d",G.adjlist[p->adjvex].data);
                visted[p->adjvex] = 1;
                rear = (rear+1)%20;
                queue[rear] = p->adjvex;
            }
            p = p->next;
        }
    }
}

void BFSTraverse(AGraph G){
    for (int i = 0; i < G.vexnum; ++i) {
        visted[i] = 0;
    }
    for (int i = 0; i < G.vexnum; ++i) {
        if (visted[i]==0){
            BFS(G,i);
        }
    }
}

四：备注

本篇博客主要介绍的是邻接表存储的深度和广度优先遍历算法，其中队列使用的是数组来模拟，没有单独使用队列函数。
若查看使用邻接矩阵表示的图的构造、深度、广度优先遍历算法，请查看这篇博客
图的邻接矩阵表示