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

题目描述

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

示例输入

示例输出

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");
}
}