邻接表的深度优先遍历

对《大话数据结构》P241——邻接表的深度优先遍历，进行了自己的理解并完善了代码。

邻接矩阵的深度优先遍历见http://www.cnblogs.com/hslzju/p/5399249.html

举个简单的无序图例子，为了节省时间传手稿。

首先用邻接表的存储结构创建该图，再进行深度优先遍历。

代码和解释如下（VS2012测试通过）：

#include <iostream>
#include <stdlib.h>
using namespace std;

typedef struct EdgeNode//边表节点
{
    int adjvex;//存储该顶点对应的下标
    struct EdgeNode *next;//指向该顶点的下一个邻接点
}EdgeNode;

typedef struct VertexNode//顶点表结点
{
    char data;//顶点
    EdgeNode *firstedge;//边表头指针
}VertexNode;

typedef struct//图的邻接表存储结构
{
    VertexNode adjList[4];//有4个VertexNode这种类型的顶点，定义一个数组adjList[4]，每个元素是VertexNode类型
    int numVertexes,numEdges;//图中顶点数和边数，这里是4,5
}GraphAdjList;

GraphAdjList *CreateALGraph(GraphAdjList *Gp)//无向图的邻接表创建
{
    Gp=(GraphAdjList *)malloc(sizeof(GraphAdjList));
    //申请一片GraphAdjList大小的类型很重要，否则Gp指向NULL（GL传的值是NULL），程序就运行崩溃了
    EdgeNode *pe;//定义边表指针类型pe
    cout << "input numNodes and numEdges:" << endl;
    cin >> Gp->numVertexes >> Gp->numEdges;//输入4 5
    for (int k = 0 ; k < Gp->numVertexes; k++)
    {
        cout << "input VertexType data:" << endl;
        cin >> Gp->adjList[k].data;//输入A B C D
        Gp->adjList[k].firstedge = NULL;//将边表头指针指向NULL，即置为0
    }
    for (int k = 0; k <  Gp->numEdges; k++)//建立边表
    {
        int i,j;
        cout << "input vi and vj:" << endl;
        cin >> i >> j;//每次循环依次输入0 1,0 2,0 3,1 2,2 3

        pe = (EdgeNode *)malloc(sizeof(EdgeNode));
        pe->adjvex = j;// 邻接序号为j
        pe->next = Gp->adjList[i].firstedge;//将pe的指针指向当前顶点指向的结点
        Gp->adjList[i].firstedge = pe;//将当前顶点的指针指向pe

        pe = (EdgeNode *)malloc(sizeof(EdgeNode));
        pe->adjvex = i;
        pe->next = Gp->adjList[j].firstedge;
        Gp->adjList[j].firstedge = pe;//无序图重复上面步骤
    }
    return Gp;
}

int visited[5]={0};//设置为全局变量，DFS和DFSTraverse函数都有用到
//以下标为i的顶点adjList[i].data开始访问，进行一次深度优先递归，对连通图，可以访问到所有的顶点
void DFS(GraphAdjList *G,int i)
{
    EdgeNode *p;//定义指向边表的指针p
    visited[i]=1;//访问过的顶点标记为1
    cout<<G->adjList[i].data<<" ";//递归之前需要打印当前访问的顶点

    p=G->adjList[i].firstedge;//p指向该顶点的第一个边表
    while(p)//如果指向的边表不为空
    {
        if(!(visited[p->adjvex]))//如果p->adjvex为下标的顶点没有被访问过
            DFS(G,p->adjvex);//那就访问以p->adjvex为下标的顶点
        p=p->next;//回到调用处，把p移动到p->next，下面会用图说明调用顺序
    }
}

//邻接表的深度遍历
void DFSTraverse(GraphAdjList *G)
{
    for(int i=0;i<G->numVertexes;i++)
        visited[i]=0;//初始化所有顶点都是未访问过
    for(int i=0;i<G->numVertexes;i++)
        if(!visited[i]) DFS(G,i);
    //从adjList[i].data开始进行深度优先递归，若是连通图，只会执行一次DFS(G,0)
    //因为深度优先递归后每个visited[i]都是1，不会再执行if了
    //若是非连通图，可能会执行到DFS(G,1)，DFS(G,2)，DFS(G,3)，DFS(G,4)
}

int main(void)
{
    GraphAdjList *p=NULL;
    p=CreateALGraph(p);
    //以下是验证图的创建是否正确
    cout<<p->adjList[0].firstedge->adjvex<<endl;//输出3，A的第一个指向是D
    cout<<p->adjList[0].firstedge->next->adjvex<<endl;//输出2，A第二个指向是C
    cout<<p->adjList[0].firstedge->next->next->adjvex<<endl;//输出1，A的第三个指向是B
    cout<<p->adjList[1].firstedge->adjvex<<endl;//输出2，B的第一个指向是C
    cout<<p->adjList[1].firstedge->next->adjvex<<endl;//输出0，B第二个指向是A
    cout<<p->adjList[2].firstedge->adjvex<<endl;//输出3，C的第一个指向是D
    cout<<p->adjList[2].firstedge->next->adjvex<<endl;//输出1，C第二个指向是B
    cout<<p->adjList[2].firstedge->next->next->adjvex<<endl;//输出0，C的第三个指向是A
    cout<<p->adjList[3].firstedge->adjvex<<endl;//输出2，D的第一个指向是C
    cout<<p->adjList[3].firstedge->next->adjvex<<endl;//输出0，D第二个指向是A

//    DFS(p,0);//举个例子，若从下标0开始，执行一次DFS(p,0)，输出的遍历顺序是ADCB
    DFSTraverse(p);//输出的遍历顺序是ADCB
    return 0;
}

1、先理解void DFS(GraphAdjList *G,int i)这个函数，假设从下标2开始，执行一次DFS(p,0)，那么遍历结果是ADCB

main函数中用DFS(p,2);把DFSTraverse(p);注释掉。

运行结果：

由于是连通图，执行一次DFS(p,0)即可遍历全部顶点。

2、考虑问题得全面，如果是非连通图，执行一次DFS(G,0)，会有顶点没有被遍历到。解决办法是依次执行DFS(G,0)，DFS(G,1)，DFS(G,2)，DFS(G,3)，DFS(G,4)即可。用visited[i]对是否访问过该顶点标记，防止不必要的循环。

main函数中用DFSTraverse(p);把DFS(p,0);注释掉。

运行结果同1。