图的DFS递归和非递归

看以前写的文章：

图的BFS：http://www.cnblogs.com/youxin/p/3284016.html

DFS：http://www.cnblogs.com/youxin/archive/2012/07/28/2613362.html

递归：

参考了算法导论

int parent[50];
int color[];//0代表white,1 gray 2 black
static int time=;
int d[];//顶点v第一次被发现（并置v为gray色）
int f[];//结束检测v的邻接表（并置v为黑色）
void DFS(Graph G,int u);
void DFSTraverse(Graph G,void (*Visit)(VextexType v))
{
     visitFunc=Visit;
     for(int i=;i<G.vexnum;i++)
     {
         color[i]=;
         parent[i]=-;
     }
     time=;
     for(int i=;i<G.vexnum;i++)
     {
         if(color[i]==) //未访问
             DFS(G,i);
     }
}

void DFS(Graph G,int u)
{
    color[u]=;//white vextex has just been discovered
    visitFunc(G.vertices[u].data);
    time=time+;
    d[u]=time;
    ArcNode *p=G.vertices[u].firstarc;
    while(p)
    {
        int v=p->adjvex;
        if(color[v]==)
        {
            parent[v]=u;
            DFS(G,v);
        }
        p=p->nextarc;
    }
    color[u]=;//black,it's finished
    f[u]=time=time+;
}

   DFSTraverse(G,visit);
     cout<<endl;

     for(int i=;i<G.vexnum;i++)
         cout<<i<<ends<<parent[i]<<endl;
     cout<<endl;

     for(int i=;i<G.vexnum;i++)
         cout<<i<<ends<<d[i]<<"----"<<f[i]<<endl;

可以看到DFS输出：

v1 v3 v7 v6 v2 v5 v8 v4。

非递归要用到栈。

void DFS2(Graph G,int u)
{

    stack<int> s;
    visited[u]=true;
    s.push(u);

    while(!s.empty())
    {
        int v=s.top();s.pop();

        visitFunc(G.vertices[v].data);

        ArcNode *p=G.vertices[v].firstarc;
        while(p)
        {
            if(!visited[p->adjvex])
            {
                s.push(p->adjvex);
                visited[p->adjvex]=true;

            }
            p=p->nextarc;
        }

    }
}

写非递归时千万要记住的是，进栈时一定要设置visited[i]=true（包括原顶点）;不然有些节点会重复进栈。DFS和

二叉树的先序遍历是一样的，只不过二叉树只有2个分支，要要进右分支，在进左分支，而图只要是邻接点都进去，不分先后。

下面的代码写的比较烂：（不要用，用上面的）

void DFS2(Graph G,int u)
{
    color[u]=;//white vextex has just been discovered
    visitFunc(G.vertices[u].data);
    time=time+;
    d[u]=time;
    stack<int> s;
    ArcNode *p=G.vertices[u].firstarc;
    while(p)
    {
        color[p->adjvex]=;
        s.push(p->adjvex);
        p=p->nextarc;
    }
    while(!s.empty())
    {
        int v=s.top();s.pop();
        //color[v]=1;//white vextex has just been discovered,这句话可以不要，因为在进栈时已经设置了
        visitFunc(G.vertices[v].data);

        ArcNode *p2=G.vertices[v].firstarc;
        while(p2)
        {
            if(color[p2->adjvex]==)
            {
                s.push(p2->adjvex);
                color[p2->adjvex]=;//每次进栈都要设置1

            }
            p2=p2->nextarc;
        }

    }
}

这里的d[ ]和f【】不好写。

输出：

v1 v2 v4v8 v5 v3 v6 v7

邻接矩阵的非递归代码：

#include
#include
#define max_node 20
#define max 20000
using namespace std;

int map[max_node][max_node];

void dfs(int start,int n)
{
    stack s;
    int i,vis[max_node],ctop;
    memset(vis,,sizeof(vis));
    vis[start] = ;
    printf("%d ",start);
    for (i = ;i <= n;i++)
        if(!vis[i] && map[i][start] == )
        {
            vis[i] = ;
            s.push(i);
        }
    while(!s.empty())
    {
        ctop = s.top();
        vis[ctop] = ;
        printf("%d ",s.top());
        s.pop();
        for (i = ;i <= n;i++)
            if(!vis[i] && map[i][ctop] == )
            {
                vis[i] = ;
                s.push(i);
            }
    }
}

int main()
{
    int s,t,n;
    scanf("%d",&n);
    memset(map,max,sizeof(map));
    while()
    {
        scanf("%d %d",&s,&t);
        if(s == ) break;
        map[s][t] = map[t][s] = ;
    }
    dfs(,n);
    return ;
}
输入：

输出：
       

图的深度优先算法的递归版本相当简洁好懂。将递归版本的算法改写成非递归版本的难度并不大，关键是要处理好如何正确的在搜索的过程中存储搜索树中的子结点，并正确的进行访问.一种实现采用了两个栈，而另一种则使用一个结点类型为队列的栈..