邻接链表及图的遍历

//
// Created by Cute on 16-10-30.
// Copyright (c) 2016年 Cute. All rights reserved.
//

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

#define MAX_VEXTEX_NUM 9 /* 顶点数 */
#define ARC_NUM 12 /* 边数 */
#define MAX_QUEUEMEM (MAX_VEXTEX_NUM+1)

/* 顶点连接信息 */
int GraphEdge[ARC_NUM * 2][2] = {{0,1},{1,0},{1,2},{2,1},{2,3},{3,2},{3,4},{4,3},
                                 {4,5},{5,4},{5,0},{0,5},{0,6},{6,0},{6,8},{8,6},
                                 {6,7},{7,6},{7,8},{8,7},{7,3},{3,7},{8,4},{4,8}};
/*定义数组visited用来标示一个顶点是否被访问过*/
int visited[MAX_VEXTEX_NUM]={0,0,0,0,0,0,0,0,0};

/*定义除了头节点外的其他结点 */
typedef struct Node {
    int adjvex; /* 邻接的顶点 */
    struct Node *nav; /* next adjacent vex 其他邻接点 */
} Node;

/* 该结构只是为了定义头结点，单独定义头结点处理可能方便点 */
typedef struct VNode {
    int head; /* 顶点信息 */
    struct Node *fav; /* first adjacent vex第一个邻接点 */
} VNode;


/* 定义图的结构 */
typedef struct {
    VNode vex[MAX_VEXTEX_NUM];/* Linklist head array */
    int vnum; /* vex number */
    int anum; /* arc number */
} ALGraph;

void CreateGraph(ALGraph * alGraph)
{
    int i,j;
    Node *newNd;
    Node *vexNd;

    alGraph->vnum = MAX_VEXTEX_NUM;
    alGraph->anum = ARC_NUM;

    /* 初始化表头 */
    for(i=0;i<MAX_VEXTEX_NUM;i++)
    {
        alGraph->vex[i].head = i;
        alGraph->vex[i].fav = NULL;
    }

    for(j=0;j<2*ARC_NUM;j++)
    {
        i = GraphEdge[j][0];//起始

        if(alGraph->vex[i].fav==NULL)
        {
            newNd = ( Node * ) malloc (sizeof(Node));
            newNd->adjvex = GraphEdge[j][1];
            newNd->nav = NULL;
            alGraph->vex[i].fav = newNd;
        }
        else
        {
            vexNd = alGraph->vex[i].fav;
            while(vexNd->nav != NULL)
            {
                vexNd = vexNd->nav;
            }
            newNd = ( Node * ) malloc (sizeof(Node));
            newNd->adjvex = GraphEdge[j][1];
            newNd->nav = NULL;
            vexNd->nav = newNd;
        }
    }
}

void OutputGraph(ALGraph * alGraph)
{
    int i;
    Node * vexNd;

    printf("The graph dedicated by adjacency list is:\n");

    for(i=0;i<MAX_VEXTEX_NUM;i++)
    {
        printf("the header is: [%d]  -> ",alGraph->vex[i].head);
        vexNd = alGraph->vex[i].fav;

        while(vexNd != NULL)
        {
            printf("[%d] -> ",vexNd->adjvex);
            vexNd=vexNd->nav;
        }

        printf("[END]\n");
    }
}

void DFS(ALGraph * alGraph,int v)
{
    int w;
    Node * vexNd;

    visited[v] = 1;
    printf("[%d] -> ",v);

    vexNd = alGraph->vex[v].fav;

    while(vexNd != NULL)
    {
        w = vexNd->adjvex;

        if(visited[w]==0)
            DFS(alGraph,w);

        vexNd = vexNd->nav;
    }
}

void DFSTraverse(ALGraph * alGraph)
{
    int i;

    /*访问标志数组初始化*/
    for(i=0;i<MAX_VEXTEX_NUM;i++)
    {
        visited[i] = 0;
    }

    printf("\n");

    puts("********************************************");
    puts("*  the function DFSTraverse will traverse  *");
    puts("*     the graphby Depth First Search       *");
    puts("********************************************");
    puts("the result of DFS is:");

    for(i=0;i<MAX_VEXTEX_NUM;i++)
    {
        if(visited[i] == 0)
            DFS(alGraph,i);
    }

    printf("[end]\n");
}

typedef struct {
    int queuemem[MAX_QUEUEMEM];
    int header;
    int rear;
} QUEUE;

void InitQueue(QUEUE *queue)
{
    queue->header = 0;
    queue->rear = 0;
}

void EnQueue(QUEUE *queue,int v)
{
    queue->queuemem[queue->rear] = v;
    queue->rear++;
}

int DelQueue(QUEUE *queue)
{
    return queue->queuemem[queue->header++];
}

int EmptyQueue(QUEUE *queue)
{
    if(queue->header == queue->rear)
        return 1;

    return 0;
}

void BFSTraverse(ALGraph * alGraph)
{
    int i;
    int w;

    Node * vexNd;
    QUEUE queue;
    InitQueue(&queue);

    /*访问标志数组初始化*/
    for(i=0;i<MAX_VEXTEX_NUM;i++)
    {
        visited[i] = 0;
    }

    printf("\n");
    puts("********************************************");
    puts("*  the function BFSTraverse will traverse  *");
    puts("*     the graph by Breadth First Search    *");
    puts("********************************************");
    puts("the result of BFS is:");

    for(i=0;i<MAX_VEXTEX_NUM;i++)
    {
        if(visited[i] == 0)
        {
            visited[i] = 1;
            printf("[%d] -> ",i);
            EnQueue(&queue,i);

            while(!EmptyQueue(&queue))
            {
                w = DelQueue(&queue);
                vexNd = alGraph->vex[w].fav;

                while(vexNd != NULL)
                {
                    w = vexNd->adjvex;
                    if(visited[w]==0)
                    {
                        visited[w] = 1;
                        printf("[%d] -> ",w);
                        EnQueue(&queue,w);
                    }
                    vexNd = vexNd->nav;
                }
            }
        }
    }

    printf("[end]\n");
}

int main(int argc, const char * argv[])
{
    ALGraph alGraph;

    CreateGraph(&alGraph);

    OutputGraph(&alGraph);

    DFSTraverse(&alGraph);

    BFSTraverse(&alGraph);

    return 0;
}