关于深度优先遍历图的非递归算法的一个讨论

参考：

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("
");
    //    DFS1(G,0);
    //    printf("
");
    //    BFS(G,0);
    //    printf("
");
    }
    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再一次 入栈。所以算法一不正确。