图的遍历

图的遍历分为：深度优先遍历和广度优先遍历

深度优先遍历（depth first search）简称DFS

深度优先遍历其实就是一个递归的过程，像是树的前序遍历

它的思想：它从图中某个结点v出发，访问此节点，然后从v的未被访问的邻接点出发深度优先遍历图，直至图中所有和v

有路径相通的顶点都被访问到。

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

/*
**邻接矩阵
*/

typedef char VertexType;
typedef int EdgeType;
#define MAXVEX 100
#define INFINITY 65525
typedef struct
{
    VertexType vexs[MAXVEX];
    EdgeType arc[MAXVEX][MAXVEX];
    int numVertexes,numEdges;
}MGraph;

/*建立无向网图的邻接矩阵表示*/

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

    printf("输入顶点数和边数：\n");
    scanf("%d,%d",&G->numVertexes,&G->numEdges);

    for(i=0;i<G->numVertexes;i++)
    {
        scanf(&G->vexs[i]);
    }
    
    for(i=0;i<G->numVertexes;i++)
    {
        for(j=0;j<G->numVertexes;j++)
        {
            G->arc[i][j]=INFINITY;
        }

    }

    for(k=0;k<G->numEdges;k++)
    {
        printf("输入边(vi,vj)上的下标i,下标j和权w:\n");
        scanf("%d,%d,%d",&i,&j,&w);

        G->arc[i][j]=w;
        G->arc[j][i]=G->arc[i][j];
    }
}

/*
**深度优先遍历（邻接矩阵）
*/
#define MAX 10
#define TRUE 1
#define FALSE 0
typedef int Boolean;
Boolean visited[MAX];

/*邻接矩阵的深度优先递归算法*/

void DFS(MGraph G,int i)
{
    int j;
    visited[i]=TRUE;

    printf("%c ",G.vexs[i]);

    for(j=0;j<G.numVertexes;j++)
    {
        if(G.arc[i][j]==1 && !visited[j])
        {
            DFS(G,j);
        }
    }
}
/*邻接矩阵的深度遍历操作*/
void DFSTraverse(MGraph G)
{
    int i;

    for(i=0;i<G.numVertexes;i++)
    {
        visited[i]=FALSE;
    }

    for(i=0;i<G.numVertexes;i++)
    {
        if(!visited[i])
            DFS(G,i);
    }
}
int main()
{
    MGraph g;
    CreateMGraph(&g);
    DFSTraverse(g);

    return 0;
}

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

/*
**邻接表
*/

#define MAXVEX 10
typedef char VertexType;    /*定点类型*/
typedef int EdgeType;       /*边的权值类型*/

/*边表结点*/
typedef struct EdgeNode
{
    int adjvex;         /*邻接点域*/
    EdgeType weight;;   /*用于存储权值*/
    struct EdgeNode *next;/*链域，指向下一个邻接点*/
}EdgeNode;

/*定点表结点*/
typedef struct VertexNode
{
    VertexType data;    /*顶点域*/
    EdgeNode *firstedge;/*边表头指针*/
}VertexNode,AdjList[MAXVEX];

typedef struct
{
    AdjList adjList;
    int numVertexes,numEdges;
}GraphAdjList;

/*建立图的邻接表结构*/

void CreateALGraph(GraphAdjList *G)
{
    int i,j,k;

    EdgeNode *e;

    printf("输入顶点数和边数:\n");
    scanf("%d,%d",&G->numVertexes,&G->numEdges);    /*输入顶点数和边数*/

    for(i=0;i<G->numVertexes;i++)       /*建立顶点表*/
    {
        scanf(&G->adjList[i].data);     /*输入顶点信息*/
        G->adjList[i].firstedge=NULL;   /*将边表置为空表*/
    }

    for(k=0;k<G->numEdges;k++)          /*建立边表*/
    {
        printf("输入边(vi,vj)上的顶点序号:\n");
        scanf("%d,%d",&i,&j);

        e=(EdgeNode *)malloc(sizeof(EdgeNode));

        e->adjvex=j;
        e->next=G->adjList[i].firstedge;
        G->adjList[i].firstedge=e;

        e=(EdgeNode *)malloc(sizeof(EdgeNode));

        e->adjvex=i;
        e->next=G->adjList[j].firstedge;
        G->adjList[j].firstedge=e;
    }
}
/*
**深度优先遍历（邻接表）
*/
#define MAX 10
#define TRUE 1
#define FALSE 0
typedef int Boolean;
Boolean visited[MAX];

/*邻接表的深度优先递归算法*/

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(GL,i);
    }
}
int main()
{
    GraphAdjList g;
    CreateALGraph(&g);
    DFSTraverse(g);

    return 0;
}

广度优先遍历（breadth first search）简称BFS

广度优先遍历相当于树的层序遍历了

/*邻接表的广度遍历操作*/
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;
                }
            }
        }
    }
}

/*邻接矩阵的广度遍历算法*/
void BFSTraverse(MGraph G)
{
    int i,j;
    Queue  Q;
    
    for(i=0;i<G.numVertexes;i++)
    {
        visited[i]=FALSE;
    }
    InitQueue(&Q);
    
    for(i=0;i<G.numVertexes;i++)
    {
        if(!visited[i])
        {
            visited[i]=TRUE;
            printf("%c ",G.vexs[i]);
            EnQueue(&Q,i);
            
            while(!QueueEmpty(Q))
            {
                DeQueue(&Q,&i);
                
                for(j=0;j<G.numVertexes;j++)
                {
                    if(G.arc[i][j]==1 && !visited[j])
                    {
                        visited[j]=TRUE;
                        printf("%c ",G.vexs[j]);
                        EnQueue(&Q,j);
                    }
                }
            }
        }
    }
}