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

题目描述

给定一个无向连通图，顶点编号从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 <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(
cf78
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");

   }

}