图的邻接矩阵存储方式下的深度、广度优先遍历算法 （c语言，链队列，图的遍历，深度优先，广度优先）

源代码

/************************** 图的邻接矩阵与深度广度优先 ***********************************/
#include<stdio.h>
#define Maxsize 100
typedef struct abc
{
    int vertex[Maxsize];
    int edges[Maxsize][Maxsize];
    int v_num,e_num;

}MGraph;
MGraph *init_graph();
void DFS(MGraph *g,int visited[],int i);//深度优先
void DFS_Travel(MGraph *g);
/************************** 队列start ***********************************/
typedef struct bcd
{
    int data;
    struct abc *next;
}Queue;
void in_Queue(Queue **p_rear,int data);
int out_Queue(Queue **p_rear);
int empty_Queue(Queue **p_rear);

Queue* init_Queue();
/************************** 队列end ***********************************/
int main()
{

    MGraph *g=init_graph();
    //DFS_Travel(g);//深度优先
    BFS_Travel(g);//广度优先
    return 0;
}
void DFS(MGraph *g,int visited[],int i)//从i结点一次深度优先遍历
{
    int j;
    for(j=0;j<g->v_num;j++)
    {
        if(visited[j]!=1&&g->edges[i][j]==1)
        {
            visited[j]=1;
            printf("->v%d",j);
            DFS(g,visited,j);
            break;
        }
    }

}
void DFS_Travel(MGraph *g)//深度优先遍历
{
    int i;
    int visited[g->v_num];
    for(i=0;i<g->v_num;i++)
    {
        visited[i]=0;
    }

    printf("%d",g->v_num);
    for(i=0;i<g->v_num;i++)
    {
        if(visited[i]!=1)
        {
            printf("\nv%d",i);
            visited[i]=1;
            DFS(g,visited,i);
        }
    }
}
void BFS(MGraph *g,int visited[],int i)//从i结点一次广度优先遍历
{
    //Queue *Q=init_Queue();
    Queue *rear=init_Queue();
    Queue **Q=&rear;
    int j;

    visited[i]=1;
    printf("\nv%d",i);
    in_Queue(Q,i);

    while(!empty_Queue(Q))
    {
        int out=out_Queue(Q);
        for(j=0;j<g->v_num;j++)
        {
            if(visited[j]!=1&&g->edges[out][j]==1)
            {
                visited[j]=1;
                printf("->v%d",j);
                in_Queue(Q,j);
                break;
            }
        }
    }



}
void BFS_Travel(MGraph *g)//广度优先遍历
{
    int i;
    int visited[g->v_num];
    for(i=0;i<g->v_num;i++)
    {
        visited[i]=0;//visited初始化
    }
    for(i=0;i<g->v_num;i++)
    {
        if(!visited[i])
        {
            BFS(g,visited,i);
        }
    }
}
MGraph *init_graph()
{
    int i,j,k,n,e;
    printf("input n and e\n");
    scanf("%d%d",&n,&e);
    MGraph *g=(MGraph *)malloc(sizeof(MGraph));
    g->v_num=n;
    g->e_num=e;
    printf("input vertex\n");
    for(i=0;i<n;i++)
    {
        scanf("%d",&g->vertex[i]);
    }
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            g->edges[i][j]=0;
        }
    }
    printf("input edges\n");
    for(k=0;k<e;k++)
    {
        scanf("%d%d",&i,&j);
        g->edges[i][j]=1;
        g->edges[j][i]=1;
    }
    return g;
}
Queue* init_Queue()
{
    Queue *rear;
    rear=(Queue *)malloc(sizeof(Queue));
    rear->data=0;
    rear->next=rear;

    return rear;
}
void in_Queue(Queue **p_rear,int data)
{

    Queue *p=(Queue *)malloc(sizeof(Queue));
    p->data=data;
    p->next=(*p_rear)->next;
    (*p_rear)->next=p;
    (*p_rear)=p;
}
int out_Queue(Queue **p_rear)
{

    if((*p_rear)->next==(*p_rear))//队列为空
    {
        printf("out failed,beacause the seq is empty\n");
        return -99;
    }
    else
    {
        Queue *H=(*p_rear)->next;

        Queue *p=H->next;
        int result=p->data;

        H->next=p->next;
        free(p);
        if(H->next==H)
            (*p_rear)=H;
        return result;
        return 0;
    }
}
int empty_Queue(Queue **p_rear)
{
    if((*p_rear)->next==(*p_rear))//队列为空
    {
        //printf("out failed,beacause the seq is empty\n");
        return 1;
    }
    return 0;
}

输入数据说明：

初始化时，第一行输入为图的节点个数 n 和边数e，接下来的一行有n个用空格隔开的数，用于输入节点的信息，再接下来有e行，每行代表一条边的两端的节点。（后期此需要优化为带权值的输入，当前代码不含权值）（测试数据对应的图后面补）

测试数据1：

4 4
0 1 2 3
0 1
1 3
0 3
3 2

其他测试数据：

4 5
0 1 2 3
0 1
1 3
0 3
3 2
1 2

5 4
0 1 2 3 4
0 1
1 3
0 3
3 2