歡迎來到Linux教程網
Linux教程網
Linux教程網
Linux教程網
您现在的位置: Linux教程網 >> UnixLinux >  >> Linux編程 >> Linux編程

算法:深度優先算法和廣度優先算法

算法:深度優先算法和廣度優先算法(基於鄰接矩陣)

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有路徑相通的頂點都被訪問;
      ③若此時圖中尚有頂點未被訪問,則從一個未被訪問的頂點出發,重新進行深度優先遍歷,直到圖中所有頂點均被訪問過為止。

    比如:

    

    在這裡為了區分已經訪問過的節點和沒有訪問過的節點,我們引入一個一維數組bool visited[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(n2),n為頂點數,算法時間復雜度為O(n2)   

  廣度優先

    數組表示:查找每個頂點的鄰接點所需時間為O(n2),n為頂點數,算法的時間復雜度為O(n2)

Copyright © Linux教程網 All Rights Reserved