2. 程式人生 > >資料結構----BFS和DFS詳解

資料結構----BFS和DFS詳解

阿新 • • 發佈：2019-01-06

前言
The art of teaching is the art of assisting discovery.
Name:Willam
Time:2017/2/28

這篇部落格將會介紹兩種遍歷圖的演算法，一種是：DFS—-深度優先搜尋，另外一種就是：BFS–廣度優先搜尋。

1、DFS （深度優先搜尋）

演算法思路：
從頂點V開始，訪問這個頂點，然後依次從V的未被訪問的鄰接點出發深度優先遍歷圖，直至圖中所有和V有路徑的相通的頂點都被訪問了，如果此時還有頂點未被訪問，則選擇圖中未被訪問的那個頂點作為起點，重複上述動作。

具體的程式碼實現如下：

#include<iostream>
 

#include<string>
using namespace std;

//使用鄰接矩陣完成圖的遍歷
struct Graph_array {
    int vexnum;  //圖的頂點數
    int edge;    //圖的邊數
    int ** arc;  //鄰接矩陣
    int kind;    //0,為有向圖，1，為無向圖
    string * infromation; //表示每個頂點的資訊

};
//使用鄰接矩陣表示的圖
void createGraph_by_array(int **edge,Graph_array & g) {
    int i = 0
 
;
    g.arc = new int*[g.vexnum];//為鄰接矩陣開闢空間
    for (i = 0; i < g.vexnum; i++)
    {
        g.arc[i] = new int[g.vexnum];
        for (int j = 0; j < g.vexnum; j++)
            g.arc[i][j] = 0;
    }   
    for (i = 0; i < g.edge; i++)
    {
        //對矩陣進行賦值
        g.arc[edge[i][0] - 1][edge[i][1
 
] - 1] = 1;
    }
}
//列印鄰接矩陣
void print_array(Graph_array g) {

    int i = 0;
    for (i = 0; i <g.vexnum; i++) {
        //cout << g.infromation[i] << " ";
        for (int j = 0; j < g.vexnum; j++) {
            cout << g.arc[i][j] << " ";
        }
        cout << endl;
    }
}
//進行DFS遍歷，
void DFS_store_array(Graph_array g,int v,bool * & visit) {
    cout << g.infromation[v] << " ";
    visit[v] = true;
    for (int i = 0; i < g.vexnum; i++) {//找出下一個位被訪問的頂點
        if (g.arc[v][i] == 0 || g.arc[v][i] == INT_MAX) { //如果兩個頂點不存在邊
            continue;
        }
        else if (!visit[i]) {//如果沒有被訪問，訪問該結點
            DFS_store_array(g, i, visit);
        }
    }
}
//呼叫對應的DFS函式進行圖的遍歷
void DFS_array_travel(Graph_array g,int begin) {
    bool * visit;
    visit = new bool[g.vexnum];
    int i;
    for (i = 0; i < g.vexnum; i++) {
        visit[i] = false;
    }
    cout << "圖的DFS遍歷結果：" << endl;
    DFS_store_array(g,begin - 1,visit);
    //如果圖是非聯通同，那麼我們這裡還需要對每個頂點遍歷一次，保證
    //全部頂點都被訪問了
    for (i = 0; i < g.vexnum; i++) {
        if (!visit[i])
            DFS_store_array(g, i,visit);
    }

}

//使用鄰接表表示圖進行圖的遍歷
//表結點
struct ArcNode {
    int adfvex;//表示該邊的另外一個頂點在頂點表中的下標
    ArcNode * next; //表示依附在該頂點的下一條邊的資訊
};
//頭結點
struct Vnode {
    string data; //記錄基本資訊i
    ArcNode * firstarc;//記錄第一條依附在該頂點的邊
};
//一個圖的結構
struct Graph_List {
    int vexnum;  //圖的頂點數
    int edge;    //圖的邊數
    Vnode * node;  //鄰接表
    int kind;    //0,為有向圖，1，為無向圖
};
//建立鄰接表
void createGraph_list(Graph_List & g, int **edge) {
    int i;
    for (i = 0; i < g.edge; i++)
    {
        ArcNode * next=new ArcNode;
        next->adfvex=edge[i][1]-1;
        next->next = NULL;
        //判斷該頂點的是否已經有邊依附
        if (g.node[edge[i][0]-1].firstarc == NULL) {
            g.node[edge[i][0]-1].firstarc = next;
        }
        else {//尋找連結串列的最後一個結點
            ArcNode * now;
            now = g.node[edge[i][0]-1].firstarc;
            while (now->next) {
                now = now->next; 
            }
            now->next = next;
        }
    }
}
//列印鄰接表
void print_list(Graph_List g) {
    int i;
    for (i = 0; i < g.vexnum; i++) {
        cout << g.node[i].data << " ";
        ArcNode * now;
        now = g.node[i].firstarc;
        while (now) {
            cout << now->adfvex << " ";
            now = now->next;
        }
        cout << endl;
    }
}
//使用DFS進行遍歷圖，在鄰接表的情況下進行遍歷
void DFS_store_list(Graph_List g, int v, bool * & visit) {
    cout << g.node[v].data << " ";
    visit[v] = true;
    ArcNode * next = g.node[v].firstarc;
    while (next) {
        if (!visit[next->adfvex]) {
            DFS_store_list(g, next->adfvex, visit);//遞迴
        }
        else {
            next = next->next;
        }
    }
}
//呼叫上面那個函式進行圖的遍歷
void DFS_list(Graph_List g, int begin) {
    int i;
    bool * visit = new bool[g.vexnum];
    for (i = 0; i < g.vexnum; i++) {
        visit[i] = false;
    }
    cout << "圖的DFS遍歷結果：" << endl;
    DFS_store_list(g, begin - 1, visit);
    for (i = 0; i < g.vexnum; i++) {
        if(!visit[i])
            DFS_store_list(g, i, visit);
    }
}
int main()
{
    Graph_array g;
    Graph_List G;
    int i;
    cout << "輸入圖的種類：" << endl;
    cin >> g.kind; G.kind = g.kind;

    cout << "輸入圖的頂點個數" << endl;
    cin >> g.vexnum; G.vexnum = g.vexnum;

    cout << "輸入圖的邊的個數（輸入時注意，無向圖的邊要比看的邊乘以2，然後輸入的記得把重複的邊也要輸進去）" << endl;
    cin >> g.edge; G.edge = g.edge;

    g.infromation = new string[g.vexnum];
    G.node = new Vnode[G.vexnum];


    cout << "輸入每個頂點資訊（如名稱）:" << endl;
    for (i = 0; i < g.vexnum; i++) {
        cin >> g.infromation[i];
        G.node[i].data = g.infromation[i];
        G.node[i].firstarc = NULL;
    }

    int ** edge_information;
    edge_information = new int*[g.edge];

    cout << "輸入每條邊兩個頂點的編號：" << endl;
    for (i = 0; i < g.edge; i++)
    {
        edge_information[i] = new int[2];
        cin >> edge_information[i][0];
        cin >> edge_information[i][1];
    }

    int **arc; //鄰接矩陣
    //構造鄰接矩陣,其中最後一次引數：1，代表無向圖，0，代表有向圖
    createGraph_by_array(edge_information,g);
    cout << "圖的鄰接矩陣為：" << endl;
    print_array(g);
    cout << endl;
    DFS_array_travel(g, 1);
    cout << endl;

    createGraph_list(G, edge_information);
    cout << "圖的鄰接表為：" << endl;
    print_list(G);
    cout << endl;
    DFS_list(G, 1);
    cout << endl;
    system("pause");
    return 0;


}

下面，我們對如下這個圖進行遍歷，
這裡寫圖片描述
使用上述程式，輸出的結果為：
（輸入時注意，無向圖的邊要比看的邊乘以2，然後輸入的記得把重複的邊也要輸進去）
這裡寫圖片描述

2、BFS （廣度優先搜尋）

BFS就是我們所說的廣度優先搜尋，它的思路就是：假設從圖中的頂點V出，在訪問了v之後，依次訪問v的各個未被訪問的鄰接點，然後，分別從這些鄰接點出發，依次訪問他們的鄰接點，並使“先被訪問的頂點的鄰接點”先於“後被訪問的鄰接點”先被訪問，直至圖中所有的頂點都被訪問到為止，防止出現非連通圖的情況，我們需要最後遍歷一遍，看是否所有的點都被訪問了，如果有未被訪問的點，那麼就把該點作為一個新的起點。

程式碼實現如下：

#include<iostream>
#include<string>
#include<queue>
using namespace std;

//使用鄰接矩陣完成圖的遍歷
struct Graph_array {
    int vexnum;  //圖的頂點數
    int edge;    //圖的邊數
    int ** arc;  //鄰接矩陣
    int kind;    //0,為有向圖，1，為無向圖
    string * infromation; //表示每個頂點的資訊

};
//使用鄰接矩陣表示的圖
void createGraph_by_array(int **edge, Graph_array & g) {
    int i = 0;
    g.arc = new int*[g.vexnum];//為鄰接矩陣開闢空間
    for (i = 0; i < g.vexnum; i++)
    {
        g.arc[i] = new int[g.vexnum];
        for (int j = 0; j < g.vexnum; j++)
            g.arc[i][j] = 0;
    }
    for (i = 0; i < g.edge; i++)
    {
        //對矩陣進行賦值
        g.arc[edge[i][0] - 1][edge[i][1] - 1] = 1;
    }
}
//列印鄰接矩陣
void print_array(Graph_array g) {

    int i = 0;
    for (i = 0; i <g.vexnum; i++) {
        //cout << g.infromation[i] << " ";
        for (int j = 0; j < g.vexnum; j++) {
            cout << g.arc[i][j] << " ";
        }
        cout << endl;
    }
}

//呼叫對應的BFS函式進行圖的遍歷
void BFS_array_travel(Graph_array g, int begin) {
    bool * visit;
    visit = new bool[g.vexnum];
    int i;
    for (i = 0; i < g.vexnum; i++) {
        visit[i] = false;
    }
    cout << "圖的BFS遍歷結果：" << endl;
    //通過我們之前說的演算法思路，我們可以知道
    //我們需要使用先進先出的資料儲存結構實現我們的BFS，其實那就是佇列
    queue<int>  q;
    for (int v = 0; v < g.vexnum; v++) {//這重迴圈是為了保證非連通同的情況下，每個頂點都可以被訪問
        if (!visit[(begin-1 + v) % g.vexnum])//注意起點不一定是v1
        {
            cout << g.infromation[(begin - 1 + v) % g.vexnum] << " ";
            visit[(begin - 1 + v) % g.vexnum] = true;
            q.push((begin - 1 + v) % g.vexnum);//初始化我們的佇列
            while (!q.empty())
            {
                int u = q.front();
                q.pop();
                for (int j = 0; j < g.vexnum; j++) {
                    if (g.arc[u][j] == 0 || g.arc[u][j] == INT_MAX) { //如果兩個頂點不存在邊
                        continue;
                    }
                    else if (!visit[j] ) {//先訪問所有和u相連的頂點，並且把它們加入佇列
                        cout << g.infromation[j] << " ";
                        visit[j] = true;
                        q.push(j);
                    }
                }
            }
        }

    }
    cout << "完成" << endl;

}

//使用鄰接表表示圖進行圖的遍歷
//表結點
struct ArcNode {
    int adfvex;//表示該邊的另外一個頂點在頂點表中的下標
    ArcNode * next; //表示依附在該頂點的下一條邊的資訊
};
//頭結點
struct Vnode {
    string data; //記錄基本資訊i
    ArcNode * firstarc;//記錄第一條依附在該頂點的邊
};
//一個圖的結構
struct Graph_List {
    int vexnum;  //圖的頂點數
    int edge;    //圖的邊數
    Vnode * node;  //鄰接表
    int kind;    //0,為有向圖，1，為無向圖
};
//建立鄰接表
void createGraph_list(Graph_List & g, int **edge) {
    int i;
    for (i = 0; i < g.edge; i++)
    {
        ArcNode * next = new ArcNode;
        next->adfvex = edge[i][1] - 1;
        next->next = NULL;
        //判斷該頂點的是否已經有邊依附
        if (g.node[edge[i][0] - 1].firstarc == NULL) {
            g.node[edge[i][0] - 1].firstarc = next;
        }
        else {//尋找連結串列的最後一個結點
            ArcNode * now;
            now = g.node[edge[i][0] - 1].firstarc;
            while (now->next) {
                now = now->next;
            }
            now->next = next;
        }
    }
}
//列印鄰接表
void print_list(Graph_List g) {
    int i;
    for (i = 0; i < g.vexnum; i++) {
        cout << g.node[i].data << " ";
        ArcNode * now;
        now = g.node[i].firstarc;
        while (now) {
            cout << now->adfvex << " ";
            now = now->next;
        }
        cout << endl;
    }
}

//利用BFS進行圖的遍歷
void BFS_list(Graph_List g, int begin) {
    int i;
    bool * visit = new bool[g.vexnum];
    for (i = 0; i < g.vexnum; i++) {
        visit[i] = false;
    }
    cout << "圖的BFS遍歷結果：" << endl;
    queue<int>  q;
    for (int v = 0; v < g.vexnum; v++) {
        if (!visit[(begin - 1 + v) % g.vexnum])//注意起點不一定是v1
        {
            cout << g.node[(begin - 1 + v) % g.vexnum].data << " ";
            visit[(begin - 1 + v) % g.vexnum] = true;
            q.push((begin - 1 + v) % g.vexnum);//初始化我們的佇列
            while (!q.empty())
            {
                int u = q.front();
                q.pop();
                ArcNode * next;
                next = g.node[u].firstarc;//獲得依附在該頂點的第一條邊的資訊
                while (next) {//遍歷該連結串列上的所有的點
                    if (!visit[next->adfvex]) {
                        cout << g.node[next->adfvex].data << " ";
                        visit[next->adfvex] = true;
                        q.push(next->adfvex);
                    }
                    next = next->next;
                }
            }
        }
    }
}
int main()
{
    Graph_array g;
    Graph_List G;
    int i;
    cout << "輸入圖的種類：" << endl;
    cin >> g.kind; G.kind = g.kind;

    cout << "輸入圖的頂點個數" << endl;
    cin >> g.vexnum; G.vexnum = g.vexnum;

    cout << "輸入圖的邊的個數" << endl;
    cin >> g.edge; G.edge = g.edge;

    g.infromation = new string[g.vexnum];
    G.node = new Vnode[G.vexnum];


    cout << "輸入每個頂點資訊（如名稱）:" << endl;
    for (i = 0; i < g.vexnum; i++) {
        cin >> g.infromation[i];
        G.node[i].data = g.infromation[i];
        G.node[i].firstarc = NULL;
    }

    int ** edge_information;
    edge_information = new int*[g.edge];

    cout << "輸入每條邊兩個頂點的編號：" << endl;
    for (i = 0; i < g.edge; i++)
    {
        edge_information[i] = new int[2];
        cin >> edge_information[i][0];
        cin >> edge_information[i][1];
    }

    int **arc; //鄰接矩陣
               //構造鄰接矩陣,其中最後一次引數：1，代表無向圖，0，代表有向圖
    createGraph_by_array(edge_information, g);
    cout << "圖的鄰接矩陣為：" << endl;
    print_array(g);
    cout << endl;
    BFS_array_travel(g, 1);
    cout << endl;

    createGraph_list(G, edge_information);
    cout << "圖的鄰接表為：" << endl;
    print_list(G);
    cout << endl;
    BFS_list(G, 1);
    cout << endl;
    system("pause");
    return 0;


}

同樣是對DFS遍歷的那個圖進行遍歷，結果如下：
這裡寫圖片描述

3、總結

上述我們採用兩種方式對圖進行的了遍歷包括了兩種表達方式：鄰接表和鄰接矩陣，首先我們看遍歷的方法上的選擇，其實這兩種遍歷演算法的時間複雜度是一樣的，它們的不同就是在於遍歷頂點的順序不同，另外，對於兩種圖的不同的表示方式，我們可以發現鄰接矩陣的表示下，圖遍歷的時間複雜度為：o（n*n），而在鄰接表的下，遍歷的時間複雜度只是：O(n+e),其中n為頂點個數，e為邊的條數，所以，在實際中需要進行圖的遍歷的情況下，我們最好是採用鄰接表的方式進行表示我們的圖。

相關推薦

資料結構----BFS和DFS詳解

前言 The art of teaching is the art of assisting discovery. Name:Willam Time:2017/2/28 這篇部落格將會介紹兩種遍歷圖的演算法，一種是：DFS—-深度優先搜尋，另外一種就是：

BFS和DFS詳解以及java實現(轉載)

作者： Leo-Yang 原文都先發布在作者個人部落格： http://www.leoyang.net/ 本文版權歸作者和部落格園共有，歡迎轉載，但未經作者同意必須保留此段宣告，且在文章頁面明顯位置給出原文連線，否則保留追究法律責任的權利. 前言

BFS和DFS詳解以及java實現

前言 圖在演算法世界中的重要地位是不言而喻的，曾經看到一篇Google的工程師寫的一篇《Get that job at Google!》文章中說到面試官問的問題中幾乎有一半的問題都可以用圖的方法去解決。由此也可以看出圖確實適用範圍確實很廣。 圖的表示 閒話不多說，首先要

資料結構BFS與DFS鄰接表

#include<bits/stdc++.h> #define MVNum 100 #define OK 1 #define ERROR 0 using namespace std; typedef int Status; typedef int OtherTnfo; typedef c

資料結構BFS與DFS的實現（鄰接矩陣）

#include<bits/stdc++.h> #define MaxInt 2e9 #define MVNum 100 #define OK 1 #define ERROR 0 using namespace std; typedef char VerTexType; typedef

Java 資料結構5：Hash詳解

雜湊表 雜湊表也稱散列表（Hash），Hash表是基於健值對（key - value）直接進行訪問的資料結構。但是他的底層是基於陣列的，通過特定的雜湊函式把key對映到陣列的某個下標來加快查詢速度，對於雜湊表來說，查詢元素的複雜度是O(1) 我們來看一下Hash

Redis資料結構之雜湊詳解

簡介 Redis本身是鍵值對資料庫，但是值對應多種資料結構，其中就有雜湊（即鍵值對），值中的鍵值對稱為field和value。 基本命令 命令 命令描述 hset key field

資料結構---拓撲排序詳解

前言 The time of test,family is best. Name:Willam Time:2017/3/6 1、拓撲排序的介紹 對一個有向無環圖(Directed Acyclic Graph簡稱DAG)G進行拓撲排序，是將G中所有頂

【資料結構】AVL樹詳解

1.什麼是AVL樹 AVL樹又稱平衡二叉搜尋樹，它能保證二叉樹高度相對平衡，儘量降低二叉樹的高度，提高搜尋效率。單純的二叉搜尋樹在最壞的情況下插入查詢刪除等操作時間複雜度會是O(N), 例如： 所以，AVL樹就能避免這種情況，使得增刪查改的時間複雜度為O(lgN). （p

【Java基礎】Jar包結構結構分析和操作詳解

一 JAR包結構分析 JAR（Java Archive FIle）Java歸檔檔案，是Java標準的文件格式，是一個或多個Java位元組碼檔案的打包壓縮檔案，採用常見的ZIP壓縮演算法，和ZIP檔案十分類似，可以直接解壓。 JAR檔案主要用來壓縮和釋

HBase資料結構與基本語法詳解

HBase中的表一般有這樣的特點： 1 大：一個表可以有上億行，上百萬列 2 面向列:面向列(族)的儲存和許可權控制，列(族)獨立檢索。 3 稀疏:對於為空(null)的列，並不佔用儲存空間，因此，表可以設計的非常稀疏。 邏輯檢視 HBase以表的形式儲存資料。表有行和列組成。列劃分為若干個列

原理：資料結構-索引 && 應用篇：MySQL索引背後的資料結構及演算法原理詳解

特點簡介： 索引檔案比資料檔案小，可以有效地裝載到記憶體。通過對記憶體索引檔案的查詢定位到記錄，然後通過一次磁碟物件讀取操作就可以獲取到需要搜尋的物件。 靜態索引結構和動態索引結構啥區別？ 我認為靜態是指新節點的加入對原有的索引結構不會發生改變，比如：稠密索引直接把新節點

資料結構基礎-Hash Table詳解

理解Hash 雜湊表(hash table)是從一個集合A到另一個集合B的對映(mapping)。 對映是一種對應關係，而且集合A的某個元素只能對應集合B中的一個元素。但反過來，集合B中的一個元素可能對應多個集合A中的元素。如果B中的元素只能對應A中的一個元素，這樣的對映被稱為一一對映。這樣的對應關係在

【資料結構】FHQ Treap詳解

FHQ Treap是什麼？ FHQ Treap，又名無旋Treap，是一種不需要旋轉的平衡樹，是範浩強基於Treap發明的。FHQ Treap具有程式碼短，易理解，速度快的優點。（當然跟紅黑樹比一下就是……）至少它在OI中算是很優秀的資料結構了。 前置知識： C++ 二叉搜尋樹的基本性質，下面會講 二叉堆

資料結構 1 線性表詳解 連結串列、 棧 、 佇列 結合JAVA 詳解

## 前言 其實在學習資料結構之前，我也是從來都沒了解過這門課，但是隨著工作的慢慢深入，之前學習的東西實在是不夠用，並且太皮毛了。太淺，只是懂得一些淺層的，我知道這個東西怎麼用，但是要優化、或者是解析，就不知道該咋弄了。比如JAVA 最有名的幾個容器: - List - Set - MAP - Queue

【資料結構與演算法】自己動手實現圖的BFS和DFS（附完整原始碼）

圖的儲存結構    本文的重點在於圖的深度優先搜尋（DFS）和廣度優先搜尋（BFS），因此不再對圖的基本概念做過多的介紹，但是要先大致瞭解下圖的幾種常見的儲存結構。    鄰接矩陣    鄰接矩陣既可以用來儲存無向圖，也可以用來儲存有向圖。該結構實際上就是用一個二維陣列（鄰接

go map資料結構和原始碼詳解

目錄 1. 前言 2. go map的資料結構 2.1 核心結體體 2.2 資料結構圖 3. go map的常用操作 3.1 建立 3.2 插

散列表（雜湊表）及其儲存結構和特點詳解

順序儲存的結構型別需要一個一個地按順序訪問元素，當這個總量很大且我們所要訪問的元素比較靠後時，效能就會很低。散列表是一種空間換時間的儲存結構，是在演算法中提升效率的一種比較常用的方式，但是所需空間太大也會讓人頭疼，所以通常需要在二者之間權衡。我們會在之後的具體演算法章節中得到更多的領悟。 什麼是散列表 讓我

佇列（queue）及其儲存結構和特點詳解

什麼是佇列？佇列就是一個隊伍。佇列和棧一樣，由一段連續的儲存空間組成，是一個具有自身特殊規則的資料結構。我們說棧是後進先出的規則，佇列剛好與之相反，是一個先進先出（FIFO，First In First Out）或者說後進後出（LILO，Last In Last Out）的資料結構。想象一下，在排隊時是不是先

棧（stack）及其儲存結構和特點詳解

棧是一個有著特殊規則的資料結構。我們熟悉漢諾塔遊戲（如圖 1 所示），這裡有一個明確的規則，即每次只能移動頂端的一個圓盤。 圖 1 漢諾塔遊戲 棧也有這個特點。我們可以將棧視為漢諾塔中的一個柱子，我們往這個柱子上放置圓盤，先放下去的一定是最後才能拿出來的，而最後放下去的一定是最先拿出來的。這也是棧的最