数据结构实验之图论二：基于邻接表的广度优先搜索遍历

数据结构实验之图论二：基于邻接表的广度优先搜索遍历

Time Limit: 1000MS Memory limit: 65536K

题目描述

给定一个无向连通图，顶点编号从0到n-1，用广度优先搜索(BFS)遍历，输出从某个顶点出发的遍历序列。(同一个结点的同层邻接点，节点编号小的优先遍历）

输入

输入第一行为整数n（0< n <100），表示数据的组数。
对于每组数据，第一行是三个整数k，m，t（0＜k＜100，0＜m＜(k-1)*k/2，0＜ t＜k），表示有m条边，k个顶点，t为遍历的起始顶点。 
下面的m行，每行是空格隔开的两个整数u，v，表示一条连接u，v顶点的无向边。

输出

输出有n行，对应n组输出，每行为用空格隔开的k个整数，对应一组数据，表示BFS的遍历结果。

示例输入

1
6 7 0
0 3
0 4
1 4
1 5
2 3
2 4
3 5

示例输出

0 3 4 2 5 1

提示

与邻接矩阵不同的是，用邻接链表来处理图会更节省空间，但是也更复杂一点相比较邻接矩阵这种数组而言。图的邻接链表实质上就是逆序建立链表的过程，但要注意的时，建立完成后，要将连接表中的元素进行排序，这样广度优先遍历出来的数据才符合逻辑！

#include<stdio.h>
#include<math.h>
#include<malloc.h>
#include<memory.h>
int v[1000];//当前要访问的节点
int queue[1000];//将访问过的节点保存到队列
int n,m,k;
struct node
{
    int data;
    struct node *next;
};
struct node *head[1000];

//初始化邻接表图
void InitG()
{
    for(int i=0;i<n;i++)
    {
        head[i]=(struct node *)malloc(sizeof(struct node));
        head[i]->data=i;
        head[i]->next=NULL;
    }
}

//建立邻接表型图
void buildG(int u,int v)
{
    struct node *p1,*p2;
    //插入节点，跟逆序建立链表形式相同
    p1=(struct node *)malloc(sizeof(struct node));
    p1->data=v;
    p1->next=head[u]->next;
    head[u]->next=p1;
    p2=(struct node *)malloc(sizeof(struct node));
    p2->data=u;
    p2->next=head[v]->next;
    head[v]->next=p2;
}

//将邻接表进行排序
void cmp()
{
    struct node *p,*q;
    for(int i=0;i<n;i++)
    {
        for(p=head[i]->next;p!=NULL;p=p->next)
        {
            for(q=p->next;q!=NULL;q=q->next)
            {
                if(p->data>q->data)
                {
                    int t;
                    t=p->data;
                    p->data=q->data;
                    q->data=t;
                }
            }
        }
    }
}

//广度优先遍历
void bfs(int k)
{
    memset(v,0,sizeof(v));
    int num1,num2;
    num1=num2=0;
    queue[num1]=k;
     num1++;
    v[k]=1;
    struct node *p;
    while(num1>num2)
    {
        int count;
        count=queue[num2++];
        for(p=head[count]->next;p!=NULL;p=p->next)
        {
            if(v[p->data]==0)
            {
                printf("%d ",p->data);
                queue[num1]=p->data;
                num1++;
                v[p->data]=1;

            }
        }
    }
}

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d %d %d",&n,&m,&k);
        int u,v;
        InitG();//初始化邻接表
        for(int i=0;i<m;i++)
        {
            scanf("%d %d",&u,&v);
            buildG(u,v);//构建邻接表
        }
        cmp();//邻接表排序
        printf("%d ",k);
        bfs(k);//广度优先遍历
        printf("\n");
    }
    return 0;
}