圖 | 兩種遍歷方式：深度優先搜尋（DFS、深搜）和廣度優先搜尋（BFS、廣搜）

阿新 • • 發佈：2018-12-28

前邊介紹了有關圖的 4 種儲存方式，本節介紹如何對儲存的圖中的頂點進行遍歷。常用的遍歷方式有兩種：深度優先搜尋和廣度優先搜尋。

深度優先搜尋（簡稱“深搜”或DFS）

圖 1 無向圖

深度優先搜尋的過程類似於樹的先序遍歷，首先從例子中體會深度優先搜尋。例如圖 1 是一個無向圖，採用深度優先演算法遍歷這個圖的過程為：

首先任意找一個未被遍歷過的頂點，例如從 V1 開始，由於 V1 率先訪問過了，所以，需要標記 V1 的狀態為訪問過；
然後遍歷 V1 的鄰接點，例如訪問 V2 ，並做標記，然後訪問 V2 的鄰接點，例如 V4 （做標記），然後 V8 ，然後 V5 ；

當繼續遍歷 V5 的鄰接點時，根據之前做的標記顯示，所有鄰接點都被訪問過了。此時，從 V5 回退到 V8 ，看 V8 是否有未被訪問過的鄰接點，如果沒有，繼續回退到 V4 ， V2 ， V1 ；
通過檢視 V1 ，找到一個未被訪問過的頂點 V3 ，繼續遍歷，然後訪問 V3 鄰接點 V6 ，然後 V7 ；
由於 V7 沒有未被訪問的鄰接點，所有回退到 V6 ，繼續回退至 V3 ，最後到達 V1 ，發現沒有未被訪問的；
最後一步需要判斷是否所有頂點都被訪問，如果還有沒被訪問的，以未被訪問的頂點為第一個頂點，繼續依照上邊的方式進行遍歷。

根據上邊的過程，可以得到圖 1 通過深度優先搜尋獲得的頂點的遍歷次序為：V1 -> V2 -> V4 -> V8 -> V5 -> V3 -> V6 -> V7

所謂深度優先搜尋，是從圖中的一個頂點出發，每次遍歷當前訪問頂點的鄰接點，一直到訪問的頂點沒有未被訪問過的鄰接點為止。然後採用依次回退的方式，檢視來的路上每一個頂點是否有其它未被訪問的鄰接點。訪問完成後，判斷圖中的頂點是否已經全部遍歷完成，如果沒有，以未訪問的頂點為起始點，重複上述過程。

深度優先搜尋是一個不斷回溯的過程。

採用深度優先搜尋演算法遍歷圖的實現程式碼為（鄰接矩陣+無向圖（有向圖也是如此））：

#include <stdio.h>

#define MAX_VERtEX_NUM 20                   //頂點的最大個數
#define 
 VRType int                          //表示頂點之間的關係的變數型別
#define InfoType char                       //儲存弧或者邊額外資訊的指標變數型別
#define VertexType int                      //圖中頂點的資料型別

typedef enum{false,true}bool;               //定義bool型常量
bool visited[MAX_VERtEX_NUM];               //設定全域性陣列，記錄標記頂點是否被訪問過

typedef struct {
    VRType adj;                             //對於無權圖，用 1 或 0 表示是否相鄰；對於帶權圖，直接為權值。
    InfoType * info;                        //弧或邊額外含有的資訊指標
}ArcCell,AdjMatrix[MAX_VERtEX_NUM][MAX_VERtEX_NUM];

typedef struct {
    VertexType vexs[MAX_VERtEX_NUM];        //儲存圖中頂點資料
    AdjMatrix arcs;                         //二維陣列，記錄頂點之間的關係
    int vexnum,arcnum;                      //記錄圖的頂點數和弧（邊）數
}MGraph;

//根據頂點本身資料，判斷出頂點在二維陣列中的位置
int LocateVex(MGraph * G,VertexType v){
    int i=0;
    //遍歷一維陣列，找到變數v
    for (; i<G->vexnum; i++) {
        if (G->vexs[i]==v) {
            break;
        }
    }
    //如果找不到，輸出提示語句，返回-1
    if (i>G->vexnum) {
        printf("no such vertex.\n");
        return -1;
    }
    return i;
}

//構造無向圖
void CreateDN(MGraph *G){
    scanf("%d,%d",&(G->vexnum),&(G->arcnum));
    for (int i=0; i<G->vexnum; i++) {
        scanf("%d",&(G->vexs[i]));
    }
    for (int i=0; i<G->vexnum; i++) {
        for (int j=0; j<G->vexnum; j++) {
            G->arcs[i][j].adj=0;
            G->arcs[i][j].info=NULL;
        }
    }
    for (int i=0; i<G->arcnum; i++) {
        int v1,v2;
        scanf("%d,%d",&v1,&v2);
        int n=LocateVex(G, v1);
        int m=LocateVex(G, v2);
        if (m==-1 ||n==-1) {
            printf("no this vertex\n");
            return;
        }
        G->arcs[n][m].adj=1;
        G->arcs[m][n].adj=1;//無向圖的二階矩陣沿主對角線對稱
    }
}

int FirstAdjVex(MGraph G,int v)
{
    //查詢與陣列下標為v的頂點之間有邊的頂點，返回它在陣列中的下標
    for(int i = 0; i<G.vexnum; i++){
        if( G.arcs[v][i].adj ){
            return i;
        }
    }
    return -1;
}

int NextAdjVex(MGraph G,int v,int w)
{
    //從前一個訪問位置w的下一個位置開始，查詢之間有邊的頂點
    for(int i = w+1; i<G.vexnum; i++){
        if(G.arcs[v][i].adj){
            return i;
        }
    }
    return -1;
}

void visitVex(MGraph G, int v){
    printf("%d ",G.vexs[v]);
}

void DFS(MGraph G,int v){
    visited[v] = true;//標記為true
    visitVex( G,  v); //訪問第v 個頂點
    //從該頂點的第一個邊開始，一直到最後一個邊，對處於邊另一端的頂點呼叫DFS函式
    for(int w = FirstAdjVex(G,v); w>=0; w = NextAdjVex(G,v,w)){
        //如果該頂點的標記位false，證明未被訪問，呼叫深度優先搜尋函式
        if(!visited[w]){
            DFS(G,w);
        }
    }
}

//深度優先搜尋
void DFSTraverse(MGraph G){//
    int v;
    //將用做標記的visit陣列初始化為false
    for( v = 0; v < G.vexnum; ++v){
        visited[v] = false;
    }
    //對於每個標記為false的頂點呼叫深度優先搜尋函式
    for( v = 0; v < G.vexnum; v++){
        //如果該頂點的標記位為false，則呼叫深度優先搜尋函式
        if(!visited[v]){
            DFS( G, v);
        }
    }
}

int main() {
    MGraph G;//建立一個圖的變數
    CreateDN(&G);//初始化圖
    DFSTraverse(G);//深度優先搜尋圖
    return 0;
}

以圖 1 為例，執行結果為：

8,9
1
2
3
4
5
6
7
8
1,2
2,4
2,5
4,8
5,8
1,3
3,6
6,7
7,3
1 2 4 8 5 3 6 7

廣度優先搜尋

廣度優先搜尋類似於樹的層次遍歷。從圖中的某一頂點出發，遍歷每一個頂點時，依次遍歷其所有的鄰接點，然後再從這些鄰接點出發，同樣依次訪問它們的鄰接點。按照此過程，直到圖中所有被訪問過的頂點的鄰接點都被訪問到。

最後還需要做的操作就是檢視圖中是否存在尚未被訪問的頂點，若有，則以該頂點為起始點，重複上述遍歷的過程。

還拿圖 1 中的無向圖為例：

假設 V1 作為起始點，遍歷其所有的鄰接點 V2 和 V3；
然後以 V2 為起始點，訪問鄰接點 V4 和 V5 ；
然後以 V3 為起始點，訪問鄰接點 V6 、 V7 ；
然後以 V4 為起始點訪問 V8 ；
然後以 V5 為起始點，由於 V5 所有的起始點已經全部被訪問，所有直接略過；
然後V6 和 V7 也是如此。
最後，以 V1 為起始點的遍歷過程結束後，還需判斷圖中是否還有未被訪問的點，由於圖 1 中沒有了，所以整個圖遍歷結束。如果還有沒被訪問的，以未被訪問的頂點為第一個頂點，繼續依照上邊的方式進行遍歷。

根據上邊的過程，可以得到圖 1 通過廣度優先搜尋獲得的頂點的遍歷次序為：V1 -> V2 -> v3 -> V4 -> V5 -> V6 -> V7 -> V8

廣度優先搜尋的實現需要藉助佇列這一特殊資料結構，實現程式碼為（鄰接矩陣+無向圖（有向圖也是如此））：：

#include <stdio.h>
#include <stdlib.h>
#define MAX_VERtEX_NUM 20                   //頂點的最大個數
#define VRType int                          //表示頂點之間的關係的變數型別
#define InfoType char                       //儲存弧或者邊額外資訊的指標變數型別
#define VertexType int                      //圖中頂點的資料型別
typedef enum{false,true}bool;               //定義bool型常量
bool visited[MAX_VERtEX_NUM];               //設定全域性陣列，記錄標記頂點是否被訪問過

typedef struct Queue{
    VertexType data;
    struct Queue * next;
}Queue;

typedef struct {
    VRType adj;                             //對於無權圖，用 1 或 0 表示是否相鄰；對於帶權圖，直接為權值。
    InfoType * info;                        //弧或邊額外含有的資訊指標
}ArcCell,AdjMatrix[MAX_VERtEX_NUM][MAX_VERtEX_NUM];

typedef struct {
    VertexType vexs[MAX_VERtEX_NUM];        //儲存圖中頂點資料
    AdjMatrix arcs;                         //二維陣列，記錄頂點之間的關係
    int vexnum,arcnum;                      //記錄圖的頂點數和弧（邊）數
}MGraph;

//根據頂點本身資料，判斷出頂點在二維陣列中的位置
int LocateVex(MGraph * G,VertexType v){
    int i=0;
    //遍歷一維陣列，找到變數v
    for (; i<G->vexnum; i++) {
        if (G->vexs[i]==v) {
            break;
        }
    }
    //如果找不到，輸出提示語句，返回-1
    if (i>G->vexnum) {
        printf("no such vertex.\n");
        return -1;
    }
    return i;
}

//構造無向圖
void CreateDN(MGraph *G){
    scanf("%d,%d",&(G->vexnum),&(G->arcnum));
    for (int i=0; i<G->vexnum; i++) {
        scanf("%d",&(G->vexs[i]));
    }
    for (int i=0; i<G->vexnum; i++) {
        for (int j=0; j<G->vexnum; j++) {
            G->arcs[i][j].adj=0;
            G->arcs[i][j].info=NULL;
        }
    }
    for (int i=0; i<G->arcnum; i++) {
        int v1,v2;
        scanf("%d,%d",&v1,&v2);
        int n=LocateVex(G, v1);
        int m=LocateVex(G, v2);
        if (m==-1 ||n==-1) {
            printf("no this vertex\n");
            return;
        }
        G->arcs[n][m].adj=1;
        G->arcs[m][n].adj=1;//無向圖的二階矩陣沿主對角線對稱
    }
}

int FirstAdjVex(MGraph G,int v)
{
    //查詢與陣列下標為v的頂點之間有邊的頂點，返回它在陣列中的下標
    for(int i = 0; i<G.vexnum; i++){
        if( G.arcs[v][i].adj ){
            return i;
        }
    }
    return -1;
}

int NextAdjVex(MGraph G,int v,int w)
{
    //從前一個訪問位置w的下一個位置開始，查詢之間有邊的頂點
    for(int i = w+1; i<G.vexnum; i++){
        if(G.arcs[v][i].adj){
            return i;
        }
    }
    return -1;
}

//操作頂點的函式
void visitVex(MGraph G, int v){
    printf("%d ",G.vexs[v]);
}

//初始化佇列
void InitQueue(Queue ** Q){
    (*Q)=(Queue*)malloc(sizeof(Queue));
    (*Q)->next=NULL;
}

//頂點元素v進佇列
void EnQueue(Queue **Q,VertexType v){
    Queue * element=(Queue*)malloc(sizeof(Queue));
    element->data=v;
    Queue * temp=(*Q);
    while (temp->next!=NULL) {
        temp=temp->next;
    }
    temp->next=element;
}

//隊頭元素出佇列
void DeQueue(Queue **Q,int *u){
    (*u)=(*Q)->next->data;
    (*Q)->next=(*Q)->next->next;
}

//判斷佇列是否為空
bool QueueEmpty(Queue *Q){
    if (Q->next==NULL) {
        return true;
    }
    return false;
}

//廣度優先搜尋
void BFSTraverse(MGraph G){//
    int v;
    //將用做標記的visit陣列初始化為false
    for( v = 0; v < G.vexnum; ++v){
        visited[v] = false;
    }
    //對於每個標記為false的頂點呼叫深度優先搜尋函式
    Queue * Q;
    InitQueue(&Q);
    for( v = 0; v < G.vexnum; v++){
        if(!visited[v]){
            visited[v]=true;
            visitVex(G, v);
            EnQueue(&Q, G.vexs[v]);
            while (!QueueEmpty(Q)) {
                int u;
                DeQueue(&Q, &u);
                u=LocateVex(&G, u);
                for (int w=FirstAdjVex(G, u); w>=0; w=NextAdjVex(G, u, w)) {
                    if (!visited[w]) {
                        visited[w]=true;
                        visitVex(G, w);
                        EnQueue(&Q, G.vexs[w]);
                    }
                }
            }
        }
    }
}

int main() {
    MGraph G;//建立一個圖的變數
    CreateDN(&G);//初始化圖
    BFSTraverse(G);//廣度優先搜尋圖
    return 0;
}

例如，使用上述程式程式碼遍歷圖 1 中的無向圖，執行結果為：

8,9
1
2
3
4
5
6
7
8
1,2
2,4
2,5
4,8
5,8
1,3
3,6
6,7
7,3
1 2 3 4 5 6 7 8

總結

本節介紹了兩種遍歷圖的方式：深度優先搜尋演算法和廣度優先搜尋演算法。深度優先搜尋演算法的實現運用的主要是回溯法，類似於樹的先序遍歷演算法。廣度優先搜尋演算法藉助佇列的先進先出的特點，類似於樹的層次遍歷。

圖 | 兩種遍歷方式：深度優先搜尋（DFS、深搜）和廣度優先搜尋（BFS、廣搜）

深度優先搜尋（簡稱“深搜”或DFS）

廣度優先搜尋

總結

圖 | 兩種遍歷方式：深度優先搜尋（DFS、深搜）和廣度優先搜尋（BFS、廣搜）

圖的兩種遍歷方式

python中的字典兩種遍歷方式

兩種遍歷方式可以唯一確定一棵二叉樹嗎？

資料結構——根據兩種遍歷方式推得另外一種遍歷方式

HashMap兩種遍歷方式

【演算法模板】二叉樹的三種遍歷方式，以及根據兩種遍歷方式建樹

python dict 兩種遍歷方式的比較

集合的兩種遍歷方式

vue.js中的兩種遍歷方式（以及substring,split,getJsonLength）

二叉樹知道其他兩種遍歷方式求另一種

二叉樹的四種遍歷方式：遞迴、非遞迴+棧、Morris（後序非遞迴還有一種單棧和雙棧的不同版本）

Map集合的兩種遍歷方式

Map的兩種遍歷方式

HashSet的兩種遍歷方式迭代器增強for

棧的兩種遍歷方式

java中Map,兩種遍歷方式

通過兩種深度優先遍歷方式重建二叉樹或者得到其余一種遍歷方式

Map的四種遍歷方式和兩種刪除方式

二叉樹三種遍歷方式及通過兩種遍歷重構二叉樹（java實現）

圖 | 兩種遍歷方式：深度優先搜尋（DFS、深搜）和廣度優先搜尋（BFS、廣搜）

深度優先搜尋（簡稱“深搜”或DFS）

廣度優先搜尋

總結

相關推薦