1.寫在前面

　　圖的儲存結構有兩種：一種是基於二維陣列的鄰接矩陣表示法。

　　　　　　　　　　　　另一種是基於連結串列的的鄰接表。

　　在鄰接矩陣中，可以如下表示頂點和邊連線關係：

說明：

　　將頂點對應為下標，根據橫縱座標將矩陣中的某一位置值設為1，表示兩個頂點向聯接。

　　圖示表示的是無向圖的鄰接矩陣，從中我們可以發現它們的分佈關於斜對角線對稱。

　　我們在下面將要討論的是下圖的兩種遍歷方法（基於矩陣的）：

　　我們已經說明了我們要用到的是鄰接矩陣表示法，那麼我首先要來構造圖：

　　矩陣圖的資料結構如下表示：

#define MaxVnum 50
typedef 
 
double AdjMatrix[MaxVnum][MaxVnum];   //表示一個矩陣，用來儲存頂點和邊連線關係
typedef struct {
    int vexnum,arcnum;　　　　　　　　　　　　　　 //頂點的個數，邊的個數
    AdjMatrix arcs;　　　　　　　　　　　　　　　　 //圖的鄰接矩陣
}Graph;

　　這樣我們可以首先來建立上述圖，為了方便，我們直接在程式碼中書寫矩陣，而不用每次除錯手動輸入了

void CreateGraph(Graph &G)
{
    G.vexnum=8;
    G.arcnum=9;
    G.arcs[
 
0][1]=1;
    G.arcs[0][2]=1;
    G.arcs[1][3]=1;
    G.arcs[1][4]=1;
    G.arcs[2][5]=1;
    G.arcs[2][6]=1;
    G.arcs[3][1]=1;
    G.arcs[3][7]=1;
    G.arcs[3][6]=1;
    G.arcs[4][1]=1;
    G.arcs[4][7]=1;
    G.arcs[5][2]=1;
    G.arcs[5][6]=1;
    G.arcs[5][5]=1;
    G.arcs[6][2]=1;
    G.arcs[6][5
 
]=1;
    G.arcs[7][3]=1;
    G.arcs[7][4]=1;
}

　　這樣我們就已經完成了準備工作，我們可以正式來學習我們的兩種遍歷方式了。

2.深度優先遍歷演算法

　　分析深度優先遍歷

　　　　從圖的某個頂點出發，訪問圖中的所有頂點，且使每個頂點僅被訪問一次。這一過程叫做圖的遍歷。

　　　　深度優先搜尋的思想：

　　　　　　①訪問頂點v；
　　　　　　②依次從v的未被訪問的鄰接點出發，對圖進行深度優先遍歷；直至圖中和v有路徑相通的頂點都被訪問；
　　　　　　③若此時圖中尚有頂點未被訪問，則從一個未被訪問的頂點出發，重新進行深度優先遍歷，直到圖中所有頂點均被訪問過為止。

　　　　比如：

　　　　在這裡為了區分已經訪問過的節點和沒有訪問過的節點，我們引入一個一維陣列boolvisited[MaxVnum]用來表示與下標對應的頂點是否被訪問過，

流程：
☐ 首先輸出 V1，標記V1的flag=true;
☐ 獲得V1的鄰接邊 [V2 V3],取出V2，標記V2的flag=true;
☐ 獲得V2的鄰接邊[V1 V4 V5],過濾掉已經flag的，取出V4，標記V4的flag=true;
☐ 獲得V4的鄰接邊[V2 V8],過濾掉已經flag的，取出V8，標記V8的flag=true;
☐ 獲得V8的鄰接邊[V4 V5],過濾掉已經flag的，取出V5，標記V5的flag=true;
☐ 此時發現V5的所有鄰接邊都已經被flag了，所以需要回溯。（左邊黑色虛線，回溯到V1，回溯就是下層遞迴結束往回返）
☐ 
☐ 回溯到V1，在前面取出的是V2，現在取出V3，標記V3的flag=true;
☐ 獲得V3的鄰接邊[V1 V6 V7]，過濾掉已經flag的,取出V6，標記V6的flag=true;
☐ 獲得V6的鄰接邊[V3 V7],過濾掉已經flag的,取出V7，標記V7的flag=true;
☐ 此時發現V7的所有鄰接邊都已經被flag了，所以需要回溯。（右邊黑色虛線，回溯到V1，回溯就是下層遞迴結束往回返）

　　深度優先搜尋的程式碼

bool visited[MaxVnum];
void DFS(Graph G,int v)
{
    visited[v]= true; //從V開始訪問，flag它
    printf("%d",v);    //打印出V
    for(int j=0;j<G.vexnum;j++) 
        if(G.arcs[v][j]==1&&visited[j]== false) //這裡可以獲得V未訪問過的鄰接點
            DFS(G,j); //遞迴呼叫，如果所有節點都被訪問過，就回溯，而不再呼叫這裡的DFS
}

void DFSTraverse(Graph G) {
    for (int v = 0; v < G.vexnum; v++)
        visited[v] = false; //剛開始都沒有被訪問過

    for (int v = 0; v < G.vexnum; ++v)
        if (visited[v] == false) //從沒有訪問過的第一個元素來遍歷圖
            DFS(G, v);
}

 3.廣度優先搜尋演算法

　　　　分析廣度優先遍歷　　　　

　　　　　　所謂廣度，就是一層一層的，向下遍歷，層層堵截，還是這幅圖，我們如果要是廣度優先遍歷的話，我們的結果是V1 V2 V3 V4 V5 V6 V7 V8。

　　　　　　廣度優先搜尋的思想：

　　　　　　 　　① 訪問頂點vi ；

　　　　　　　　 ② 訪問vi 的所有未被訪問的鄰接點w1 ,w2 , …wk ；

　　　　　　　　 ③ 依次從這些鄰接點（在步驟②中訪問的頂點）出發，訪問它們的所有未被訪問的鄰接點; 依此類推，直到圖中所有訪問過的頂點的鄰接點都被訪問；

　　　說明：

　　　　　　為實現③，需要儲存在步驟②中訪問的頂點，而且訪問這些頂點的鄰接點的順序為：先儲存的頂點，其鄰接點先被訪問。 這裡我們就想到了用標準模板庫中的queue佇列來實現這種先進現出的服務。

　　　　　　老規矩我們還是走一邊流程：

　　　說明：　

　　　　 ☐將V1加入佇列，取出V1，並標記為true(即已經訪問)，將其鄰接點加進入佇列，則 <—[V2 V3]　

　　　　 ☐取出V2，並標記為true(即已經訪問)，將其未訪問過的鄰接點加進入佇列，則 <—[V3 V4 V5]

☐取出V3，並標記為true(即已經訪問)，將其未訪問過的鄰接點加進入佇列，則 <—[V4 V5 V6 V7]

☐取出V4，並標記為true(即已經訪問)，將其未訪問過的鄰接點加進入佇列，則 <—[V5 V6 V7 V8]

☐取出V5，並標記為true(即已經訪問)，因為其鄰接點已經加入佇列，則 <—[V6 V7 V8]

☐取出V6，並標記為true(即已經訪問)，將其未訪問過的鄰接點加進入佇列，則 <—[V7 V8]

☐取出V7，並標記為true(即已經訪問)，將其未訪問過的鄰接點加進入佇列，則 <—[V8]

☐取出V8，並標記為true(即已經訪問)，將其未訪問過的鄰接點加進入佇列，則 <—[]

　　廣度優先搜尋的程式碼

#include <queue>
using namespace std;
....
void BFSTraverse(Graph G)
{
    for (int v=0;v<G.vexnum;v++) //先將其所有頂點都設為未訪問狀態
        visited[v]=false;
    queue<int> Q;
    for(int v=0;v<G.vexnum;v++)    
    {
        if(visited[v]==false)   //若該點沒有訪問
        {
            Q.push(v);　　　　//將其加入到佇列中
            visited[v]=true;
            while (!Q.empty())　　//只要佇列不空，遍歷就沒有結束
            {
                int t =Q.front();　　//取出對頭元素
                Q.pop();
                printf(" %d ",t+1);  
                for(int j=0;j<G.vexnum;j++) //將其未訪問過的鄰接點加進入佇列
                    if(G.arcs[t][j]==1&&visited[j]== false)
                    {
                        Q.push(j);
                        visited[j]=true; //在這裡要設定true，因為這裡該頂點我們已經加入到了佇列，為了防止重複加入！
                    }
            }
        }
    }
}

 兩種演算法的複雜度分析

　　深度優先

　　　　陣列表示：查詢所有頂點的所有鄰接點所需時間為O(n²)，n為頂點數，演算法時間複雜度為O(n²) 　　

　　廣度優先

　　　　陣列表示：查詢每個頂點的鄰接點所需時間為O(n²)，n為頂點數，演算法的時間複雜度為O(n²)