關於深度優先遍歷圖的非遞歸算法的一個討論

參考：

http://www.cnblogs.com/kubixuesheng/p/4399705.html

http://www.cnblogs.com/dolphin0520/archive/2011/07/13/2105236.html

 

 

圖的深度優先遍歷遞歸算法大概如下：

//訪問標志數組
int visited[MAX] = {0};

//用鄰接表方式實現深度優先搜索(遞歸方式）
//v 傳入的是第一個需要訪問的頂點
void DFS(MGraph G, int v)
{
    //圖的頂點的搜索指針
    ArcNode *p;
    //置已訪問標記
    visited[v] = 1;
    //輸出被訪問頂點的編號
    printf("%d  ", v);
    //p指向頂點v的第一條弧的弧頭結點
    p = G.vertices[v].firstarc;
    while (p != NULL)
    {
        //若p->adjvex頂點未訪問,遞歸訪問它
        if (visited[p->adjvex] == 0)
        {
            DFS(G, p->adjvex);
        }
        //p指向頂點v的下一條弧的弧頭結點
        p = p->nextarc;
    }
}

圖的廣度優先遍歷算法大概如下：

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

const int MAX = 10;
//輔助隊列的初始化，置空的輔助隊列Q，類似二叉樹的層序遍歷過程
queue<int> q;
//訪問標記數組
bool visited[MAX];
//圖的廣度優先搜索算法
void BFSTraverse(Graph G, void (*visit)(int v))
{
    int v = 0;
    //初始化訪問標記的數組
    for (v = 0; v < G.vexnum; v++)
    {
        visited[v] = false;
    }
    //依次遍歷整個圖的結點
    for (v = 0; v < G.vexnum; v++)
    {
        //如果v尚未訪問，則訪問 v
        if  (!visited[v])
        {
            //把 v 頂點對應的數組下標處的元素置為真，代表已經訪問了
            visited[v] = true;
            //然后v入隊列，利用了隊列的先進先出的性質
            q.push(v);
            //訪問 v，打印處理
            cout << q.back() << " ";
            //隊不為空時
            while (!q.empty())
            {
                //隊頭元素出隊,並把這個出隊的元素置為 u，類似層序遍歷
                Graph *u = q.front();
                q.pop();
                //w為u的鄰接頂點
                for (int w = FirstAdjVex(G, u); w >= 0; w = NextAdjVex(G,u,w))
                {
                    //w為u的尚未訪問的鄰接頂點
                    if (!visited[w])
                    {
                        visited[w] = true;
                        //然后 w 入隊列，利用了隊列的先進先出的性質
                        q.push(w);
                        //訪問 w，打印處理
                        cout << q.back() << " ";
                    }//end of if
                }//end of for
            }//end of while
        }//end of if
    }// end of for
}

上面是用鄰接表結構實現的代碼。下面是用鄰接矩陣實現的代碼，包含遞歸深搜、非遞歸深搜、廣搜，可以參考一下：

#include<iostream>
#include<queue>
#include<stack>
#include<stdlib.h>
#define MAX 100
using namespace std;

typedef struct 
{
    int edges[MAX][MAX];    //鄰接矩陣
    int n;                  //頂點數
    int e;                  //邊數
}MGraph;

bool visited[MAX];          //標記頂點是否被訪問過

void creatMGraph(MGraph &G)    //用引用作參數
{
    int i,j;
    int s,t;                 //存儲頂點編號
    int v;                   //存儲邊的權值
    for(i=0;i<G.n;i++)       //初始化
    {
        for(j=0;j<G.n;j++)
        {
            G.edges[i][j]=0;
        }
        visited[i]=false;
    }
    for(i=0;i<G.e;i++)      //對矩陣相鄰的邊賦權值
    {
        scanf("%d %d %d",&s,&t,&v);   
//兩個頂點確定一條邊
//輸入邊的頂點編號以及權值
        G.edges[s][t]=v;
    }
}

void DFS(MGraph G,int v)      //深度優先搜索
{
    int i;
    printf("%d ",v);          //訪問結點v
    visited[v]=true;
    for(i=0;i<G.n;i++)       //訪問與v相鄰的未被訪問過的結點
    {
        if(G.edges[v][i]!=0&&visited[i]==false)
        {
            DFS(G,i);//若沒訪問則繼續，而且根據頂點的序號按數序訪問
        }
    }
}
//stack彈出順序有問題
void DFS1(MGraph G,int v)   //非遞歸實現
{
    stack<int> s;
    printf("%d ",v);        //訪問初始結點
    visited[v]=true;
    s.push(v);              //入棧
    while(!s.empty())
    {
        int i,j;
        i=s.top();          //取棧頂頂點
        for(j=0;j<G.n;j++)  //訪問與頂點i相鄰的頂點
        {
            if(G.edges[i][j]!=0&&visited[j]==false)
            {
                printf("%d ",j);     //訪問
                visited[j]=true;
                s.push(j);           //訪問完后入棧
                break;               //找到一個相鄰未訪問的頂點，訪問之后則跳出循環
            }
        }
//對於節點4，找完所有節點發現都已訪問過或者沒有臨邊，所以j此時=節點總數，然后把這個4給彈出來
直到彈出1，之前的深度搜索的值都已彈出，有半部分還沒有遍歷，開始遍歷有半部分
        if(j==G.n)                   //如果與i相鄰的頂點都被訪問過，則將頂點i出棧
            s.pop();
    }
}

void BFS(MGraph G,int v)      //廣度優先搜索
{
    queue<int> Q;             //STL模板中的queue
    printf("%d ",v);
    visited[v]=true;
    Q.push(v);
    while(!Q.empty()) 
    {
        int i,j;
        i=Q.front();         //取隊首頂點
        Q.pop();//彈出一個，然后遍歷這個節點的子節點，然后遍歷完再彈出下一個
        for(j=0;j<G.n;j++)   //廣度遍歷
        {
            if(G.edges[i][j]!=0&&visited[j]==false)
            {
                printf("%d ",j);
                visited[j]=true;
                Q.push(j);
            }
        }
    }
}

int main(void)
{
    int n,e;    //建立的圖的頂點數和邊數
    while(scanf("%d %d",&n,&e)==2&&n>0)
    {
        MGraph G;
        G.n=n;
        G.e=e;
        creatMGraph(G);
        DFS(G,0);
        printf("\n");
    //    DFS1(G,0);
    //    printf("\n");
    //    BFS(G,0);
    //    printf("\n");
    }
    return 0;
}

 

在網絡上查了很多資料，又去看了好幾本教材，發現這些地方對圖的深度優先遍歷算法的講解，基本都是用遞歸算法實現的。對非遞歸算法實現描述不是很多。上面第三段代碼實現了非遞歸深搜算法。

 

在尋找資料過程中，也在思考如何實現，大概設計了如下兩種算法：

算法一：（這個是一個錯誤的思路）

st.push(v1)//出發點入棧 
while(!st.empty()) 
{
    temp=st.top(); st.pop();//臨時備份棧頂節點到temp，刪除棧頂節點 
    printf(temp);//訪問temp（原先的棧頂節點） 
    根據temp尋找所有未曾訪問的相鄰節點，並把這些節點入棧
}

算法二：

printf(v1);//訪問出發節點 
st.push(v1);//出發點入棧 
while(!st.empty()) 
{
    temp=st.top();//讀取棧頂節點到temp
    循環遍歷temp的所有相鄰節點： 
    ｛
        如果（發現一個未曾訪問的相鄰節點w）：
        ｛
            printf(w);//訪問節點w
            st.push(w);//把w入棧
            退出循環
        ｝
    ｝
    if(temp沒有未曾訪問的相鄰節點) 
        st.pop();//刪除棧頂節點
}

這兩種算法，假如僅僅是對樹進行深搜，應該是沒有錯的。但是對圖進行深搜，算法一確實不正確的。看下面這個例子：

對這個圖從V0出發做深搜，假如按照算法一操作，假設節點入棧順序為：V0，V1，V3，……

其中v1和V3入棧時，V0已經出棧。但是取出棧頂V3做訪問操作，然后再把V3的相鄰未曾訪問節點入棧，則會使得V1再一次 入棧。所以算法一不正確。