浅谈数据结构之图的邻接表深度和广度优先遍历(九)

　　邻接矩阵是一种不错的图存储结构，但是我们发现，对于边数相对较少的图，这种结构是存在对存储空间的极大浪费的。我们知道，顺序存储结构存在预先分配内存可能造成空间浪费的问题，于是引出了链式存储的结构。同样的，我们也可以考虑对边或弧使用链式存储的方式来避免空间浪费的问题。因此，对于图的存储结构，我们同样引入了一种数组与链表相组合的存储方法，我们一般称之为邻接表。

　　邻接表的处理方法是这样的：(1).图中顶点用一个一维数组存储，当然，顶点也可以用单链表来存储，不过数组可以较容易的读取顶点的信息，更加方便；另外，每个数据元素还需要存储指向第一个邻接点的指针，以便于查找该顶点的边信息；(2).图中每个顶点Vi的所有邻接点构成一个线性表，由于邻接点的个数不定，所以用单链表存储，无向图称为顶点Vi的边表，有向图则称为顶点Vi作为弧尾的出边表。

　　对比图的深度优先遍历与广度优先遍历，我们发现，它们在时间复杂度上是一样的，不同之处仅仅在于对顶点的访问顺序不同，可见两者在全图遍历上是没有优劣之分的，只是视不同的情况选择不同的方式而已。不过深度优先遍历更适合于目标比较明确，以找到目标为主要目的的情况，而广度优先遍历更适合在不断扩大遍历范围时找到相对最优解的情况。

图的创建及邻接表的深度和广度优先遍历源程序代码如下所示：

#include <stdio.h>
#include <stdlib.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 9             /* 存储空间初始分配量 */
#define MAXEDGE 15
#define MAXVEX 9
#define INFINITY 65535

typedef int Status;           /* Status是函数的类型,其值是函数结果状态代码,如OK等 */
typedef int Boolean;          /* Boolean是布尔类型,其值是TRUE或FALSE */

typedef char VertexType;      /* 顶点类型应由用户定义 */   
typedef int EdgeType;         /* 边上的权值类型应由用户定义 */

/* 邻接矩阵结构 */
typedef struct
{
    VertexType vexs[MAXVEX];         /* 顶点表 */
    EdgeType arc[MAXVEX][MAXVEX];    /* 邻接矩阵,可看作边表 */
    int numVertexes, numEdges;       /* 图中当前的顶点数和边数 */ 
}MGraph;

/* 邻接表结构 */
typedef struct EdgeNode        /* 边表结点 */ 
{
    int adjvex;                /* 邻接点域,存储该顶点对应的下标 */
    int weight;                /* 用于存储权值,对于非网图可以不需要 */
    struct EdgeNode *next;  　　/* 链域,指向下一个邻接点 */ 
}EdgeNode;

typedef struct VertexNode      /* 顶点表结点 */ 
{
    int in;                    /* 顶点入度 */
    char data;                 /* 顶点域,存储顶点信息 */
    EdgeNode *firstedge;    　　/* 边表头指针 */   
}VertexNode, AdjList[MAXVEX];

typedef struct
{
    AdjList adjList; 
    int numVertexes,numEdges;         /* 图中当前顶点数和边数 */
}graphAdjList,*GraphAdjList;

/* 用到的队列结构与函数 */
/* 循环队列的顺序存储结构 */
typedef struct
{
    int data[MAXSIZE];
    int front;               /* 头指针 */
    int rear;                /* 尾指针,若队列不空,指向队列尾元素的下一个位置 */
}Queue;

/* 初始化一个空队列Q */
Status InitQueue(Queue *Q)
{
    Q->front=0;
    Q->rear=0;
    return  OK;
}

/* 若队列Q为空队列,则返回TRUE,否则返回FALSE */
Status QueueEmpty(Queue Q)
{ 
    if(Q.front==Q.rear)     /* 队列空的标志 */
        return TRUE;
    else
        return FALSE;
}

/* 若队列未满,则插入元素e为Q新的队尾元素 */
Status EnQueue(Queue *Q,int e)
{
    if ((Q->rear+1)%MAXSIZE == Q->front)        /* 队列满的判断 */
        return ERROR;
    Q->data[Q->rear]=e;                 /* 将元素e赋值给队尾 */
    Q->rear=(Q->rear+1)%MAXSIZE;        /* rear指针向后移一位置, */
                                        /* 若到最后则转到数组头部 */
    return  OK;
}

/* 若队列不空,则删除Q中队头元素,用e返回其值 */
Status DeQueue(Queue *Q,int *e)
{
    if (Q->front == Q->rear)            /* 队列空的判断 */
        return ERROR;
    *e=Q->data[Q->front];               /* 将队头元素赋值给e */
    Q->front=(Q->front+1)%MAXSIZE;      /* front指针向后移一位置, */
                                        /* 若到最后则转到数组头部 */
    return  OK;
}

void CreateMGraph(MGraph *G)
{
    int i, j;

    G->numEdges=15;
    G->numVertexes=9;

    /* 读入顶点信息,建立顶点表 */ 
    G->vexs[0]='A';
    G->vexs[1]='B';
    G->vexs[2]='C';
    G->vexs[3]='D';
    G->vexs[4]='E';
    G->vexs[5]='F';
    G->vexs[6]='G';
    G->vexs[7]='H';
    G->vexs[8]='I';

    for (i = 0; i < G->numVertexes; i++)        /* 初始化图 */
    {
        for ( j = 0; j < G->numVertexes; j++)
        {
            G->arc[i][j]=0;
        }
    }

    G->arc[0][1]=1;
    G->arc[0][5]=1;

    G->arc[1][2]=1; 
    G->arc[1][8]=1; 
    G->arc[1][6]=1; 
    
    G->arc[2][3]=1; 
    G->arc[2][8]=1; 
    
    G->arc[3][4]=1;
    G->arc[3][7]=1;
    G->arc[3][6]=1;
    G->arc[3][8]=1;

    G->arc[4][5]=1;
    G->arc[4][7]=1;

    G->arc[5][6]=1; 
    
    G->arc[6][7]=1; 

    for(i = 0; i < G->numVertexes; i++)
    {
        for(j = i; j < G->numVertexes; j++)
        {
            G->arc[j][i] =G->arc[i][j];
        }
    }
}
 
/* 利用邻接矩阵构建邻接表 */
void CreateALGraph(MGraph G,GraphAdjList *GL)
{
    int i,j;
    EdgeNode *e;

    *GL = (GraphAdjList)malloc(sizeof(graphAdjList));

    (*GL)->numVertexes=G.numVertexes;
    (*GL)->numEdges=G.numEdges;
    for(i= 0;i <G.numVertexes;i++)         /* 读入顶点信息,建立顶点表 */   
    {
        (*GL)->adjList[i].in=0;
        (*GL)->adjList[i].data=G.vexs[i];
        (*GL)->adjList[i].firstedge=NULL;         /* 将边表置为空表 */
    }
    
    for(i=0;i<G.numVertexes;i++)         /* 建立边表 */
    { 
        for(j=0;j<G.numVertexes;j++)
        {
            if (G.arc[i][j]==1)
            {
                e=(EdgeNode *)malloc(sizeof(EdgeNode));
                e->adjvex=j;                              /* 邻接序号为j */                         
                e->next=(*GL)->adjList[i].firstedge;      /* 将当前顶点上的指向的结点指针赋值给e */
                (*GL)->adjList[i].firstedge=e;            /* 将当前顶点的指针指向e */   
                (*GL)->adjList[j].in++;
                
            }
        }
    }
}

Boolean visited[MAXSIZE];         /* 访问标志的数组 */

/* 邻接表的深度优先递归算法 */
void DFS(GraphAdjList GL, int i)
{
    EdgeNode *p;
     visited[i] = TRUE;
     printf("%c ",GL->adjList[i].data);        /* 打印顶点,也可以其它操作 */
    p = GL->adjList[i].firstedge;
    while(p)
    {
         if(!visited[p->adjvex])
             DFS(GL, p->adjvex);               /* 对为访问的邻接顶点递归调用 */
        p = p->next;
     }
}

/* 邻接表的深度遍历操作 */
void DFSTraverse(GraphAdjList GL)
{
    int i;
     for(i = 0; i < GL->numVertexes; i++)
         visited[i] = FALSE;         /* 初始所有顶点状态都是未访问过状态 */
    for(i = 0; i < GL->numVertexes; i++)
         if(!visited[i])             /* 对未访问过的顶点调用DFS,若是连通图,只会执行一次 */ 
            DFS(GL, i);
}

/* 邻接表的广度遍历算法 */
void BFSTraverse(GraphAdjList GL)
{
    int i;
    EdgeNode *p;
    Queue Q;
    for(i = 0; i < GL->numVertexes; i++)
           visited[i] = FALSE;
    InitQueue(&Q);
       for(i = 0; i < GL->numVertexes; i++)
       {
        if (!visited[i])
        {
            visited[i]=TRUE;
            printf("%c ",GL->adjList[i].data);        /* 打印顶点,也可以其它操作 */
            EnQueue(&Q,i);
            while(!QueueEmpty(Q))
            {
                DeQueue(&Q,&i);
                p = GL->adjList[i].firstedge;         /* 找到当前顶点的边表链表头指针 */
                while(p)
                {
                    if(!visited[p->adjvex])           /* 若此顶点未被访问 */
                     {
                         visited[p->adjvex]=TRUE;
                        printf("%c ",GL->adjList[p->adjvex].data);
                        EnQueue(&Q,p->adjvex);        /* 将此顶点入队列 */
                    }
                    p = p->next;        /* 指针指向下一个邻接点 */
                }
            }
        }
    }
}


int main(void)
{    
    MGraph G;  
    GraphAdjList GL;    
    CreateMGraph(&G);
    CreateALGraph(G,&GL);

    printf("
1.图的邻接表的深度优先遍历为：");
    DFSTraverse(GL);
    
    printf("
2.图的邻接表的广度优先遍历为：");
    BFSTraverse(GL);
    
    return 0;
}