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

题目描述

给定一个无向连通图，顶点编号从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的遍历结果。

示例输入

16 7 00 30 41 41 52 32 43 5

示例输出

0 3 4 2 5 1

#include <iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<queue>
#define max 100
using namespace std;
queue<int>q;//将访问过的节点保存到队列
typedef int element;
typedef struct arcnode//表结点结构
{
    element adj;//该弧所指向的顶点的位置
    arcnode *next;//指向下一条弧的指针
}arcnode;
typedef struct vnode//头结点结构
{
    element data;//顶点信息
    arcnode *first;;//指向第一条依附该顶点的弧的指针
}vnode,adjlist[max];
typedef struct //图的结构；
{
    adjlist a;
    int vn,an;//图的当前顶点数和弧数
}ALG;
element k;//初始顶点；
element i,j;
element create(ALG &g)
{
    element v1,v2;
    arcnode *p;
    scanf("%d%d%d",&g.vn,&g.an,&k);
    for(i=0;i<g.vn;i++)
        g.a[i].first=NULL;
    for(i=0;i<g.an;i++)
    {
        scanf("%d%d",&v1,&v2);
        p=new arcnode;
        p->adj=v2;
        p->next=g.a[v1].first;//逆序建立链表
        g.a[v1].first=p;
        //无向图的对称性
        p=new arcnode;
        p->adj=v1;
        p->next=g.a[v2].first;
        g.a[v2].first=p;
    }
    return 1;
}
element v[110];//当前要访问的节点
void bfs(ALG &g,element k)
{
    arcnode *p;
    memset(v,0,sizeof(v));//标记数组的初始化；
    v[k]=1;
    q.push(k);
    printf("%d",k);
    while(!q.empty())
    {
        i=q.front();
        q.pop();
        p=g.a[i].first;
        {
            while(p)//依次搜索vi的邻接点vj(p->adj相当于j)
            {
                if(!v[p->adj])
                {
                    v[p->adj]=1;
                    q.push(p->adj);
                    printf(" %d",p->adj);
                }
                p=p->next;
            }
        }
    }
}
void Swap(ALG &g)//保证(同一个结点的同层邻接点，节点编号小的优先遍历）
{
    element t;
    arcnode *p,*q;
    for(i=0;i<g.vn;i++)
      for(p=g.a[i].first;p;p=p->next)
        for(q=p->next;q;q=q->next)
           if(p->adj>q->adj)
            {
              t=p->adj;
                p->adj=q->adj;
                  q->adj=t;
            }


}
element main()
{
    element n;
    ALG g;
    scanf("%d",&n);
    while(n--)
    {
        create(g);//构建邻接表
        Swap(g);//邻接表排序
        bfs(g,k);//广度优先遍历
        printf("\n");
    }
    return 0;
}

#include<iostream>
#include<queue>
#include<cstdio>
#include<cstring>
using namespace std;
int map[110][110],vis[110];
void bfs(int t,int n)
{
  queue<int>q;
   int flag=1;
   q.push(t);
   vis[t]=1;
   while(!q.empty())
   {
      int p=q.front();
      q.pop();
      if(flag)
      {flag=0;printf("%d",p);}
      else
      printf(" %d",p);
      for(int i=0;i<n;i++)
      {if(!vis[i]&&map[i][p])
         {q.push(i);
          vis[i]=1;}
      }
   }
}
int main()
{


   int T;
   cin>>T;
   while(T--)
   {  memset(vis,0,sizeof(vis));
     memset(map,0,sizeof(map));
     int n,m,t;
     cin>>n>>m>>t;
     while(m--)
      {
        int v,u;
        cin>>u>>v;
       map[u][v]=map[v][u]=1;
     }
     bfs(t,n);
    }




}

#include<cstring>
#include<algorithm>
#include<cstdio>
#include<queue>
#include<iostream>
using namespace std;
struct node
{int u,v;
  node *next;
}*head[22];
int vis[22],flag=1;
void add(int u,int v)//顺序建表；
{node *p=new node;
 p->v=v;
 p->next=head[u];
 head[u]=p;
}
int n,k,m;
//int b[110],x[110];
void bfs(int t)
{
   int p;
   queue<int>q;
   q.push(t);
   vis[t]=1;
   flag=1;
   while(!q.empty())
   {
     p=q.front();
     q.pop();
     if(flag)
     {flag=0,printf("%d",p);}
     else
     printf(" %d",p);
    for(node *h=head[p];h;h=h->next)
    {
      if(vis[h->v]==0)
      {
        q.push(h->v);
        vis[h->v]=1;
      }
    }
   }
}
int main()
{
  int i;
  int u,v,t;
   cin>>n;
   while(n--)
   {
     cin>>k>>m>>t;
     memset(head,NULL,sizeof(head));
     memset(vis,0,sizeof(vis));
     for(i=0;i<m;i++)
     {cin>>u>>v;
      add(u,v);
      add(v,u);
     }
     for(int i=0;i<m;i++)
     {
      node *p,*q;
      for(p=head[i];p;p=p->next)//对邻接链表排序
      {
         for(q=p->next;q;q=q->next)
         {
           if(p->v>q->v)
           swap(p->v,q->v);
         }
      }
     }
     bfs(t);
     printf("\n");
   }
}