淺談數據結構之圖的鄰接表深度和廣度優先遍歷(九)

　　鄰接矩陣是一種不錯的圖存儲結構，但是我們發現，對於邊數相對較少的圖，這種結構是存在對存儲空間的極大浪費的。我們知道，順序存儲結構存在預先分配內存可能造成空間浪費的問題，於是引出了鏈式存儲的結構。同樣的，我們也可以考慮對邊或弧使用鏈式存儲的方式來避免空間浪費的問題。因此，對於圖的存儲結構，我們同樣引入了一種數組與鏈表相組合的存儲方法，我們一般稱之為鄰接表。

　　鄰接表的處理方法是這樣的：(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("\n1.圖的鄰接表的深度優先遍歷為：");
    DFSTraverse(GL);
    
    printf("\n2.圖的鄰接表的廣度優先遍歷為：");
    BFSTraverse(GL);
    
    return 0;
}