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

数据结构实验图论一：基于邻接矩阵的广度优先搜索遍历

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 <bits/stdc++.h>  
using namespace std;  
int mp[105][105],bs[10005],d[10001],p[10001];  
int n,k,m,s,sum;  
/*广度优先遍历是连通图的一种遍历策略。其基本思想如下： 
1、从图中某个顶点V0出发，并访问此顶点 
2、从V0出发，访问V0的各个未曾访问的邻接点W1，W2，…,Wk;然后,依次从W1,W2,…,Wk出发访问各自未被访问的邻接点； 
3、重复步骤2，直到全部顶点都被访问为止。 
*/  
void bfs(int s)  
{  
    int out=0,in=0,v,i;  
    bs[s]=1;  
    p[sum++]=s;  
    d[in++]=s;  
    while(out<in)  
    {  
        v=d[out++];  
        for(i=0; i<k; i++)  
        {  
            if(bs[i]==0&&mp[v][i])  
            {  
                bs[i]=1;  
                p[sum++]=i;  
                d[in++]=i;  
            }  
        }  
    }  
}  
int main()  
{  
    int i,a,b;  
    cin>>n;  
    while(n--)  
    {  
        sum=0;  
        memset(bs,0,sizeof(bs));   //清零  
        cin>>k>>m>>s;  
        for(i=0; i<m; i++)  
        {  
            cin>>a>>b;  
            mp[a]=1;        //可连通的路置为1;  
            mp[b][a]=1;  
        }  
        bfs(s);  
        for(i=0; i<sum; i++)  
            printf("%d ",p[i]);     //打印遍历结果  
    }  
    return 0;  
}

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

[b]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<bits/stdc++.h>  
#define M 20  
#define swap(x,y,t) ((t)=(x),(x)=(y),(y)=(t))  
using namespace std;  
struct node  
{  
    int u,v;  
    struct node *next;  
}*head[M];  
int vis[M],f=1;  
void add(int u,int v)  
{  
    struct node *p=new node;  
    p->v=v;  
    p->next=head[u];  
    head[u]=p;  
}  
int n,k,m;  
int b[100],x[100];  
void bfs(int t)  
{  
    int q;  
    k=0;  
    queue<int>Q;  
    Q.push(t);  
    vis[t]=1;  
    f=1;  
    while(!Q.empty())  
    {  
        q=Q.front();  
        Q.pop();  
        if(f)  
        {  
            f=0;  
            printf("%d",q);  
        }  
        else printf(" %d",q);  
        for(struct node *p=head[q]; p!=NULL; p=p->next)  
        {  
            if(vis[p->v]==0)  
            {  
                Q.push(p->v);  
                vis[p->v]=1;  
            }  
        }  
    }  
}  
struct  N  
{  
    int u,v;  
} num[100];  
int main()  
{  
    int i;  
    int u,v,t;  
    scanf("%d",&n);  
    while(n--)  
    {  
        scanf("%d%d%d",&k,&m,&t);  
        memset(head,NULL,sizeof(head));  
        memset(vis,0,sizeof(vis));  
        for(i=0; i<m; i++)  
        {  
            scanf("%d%d",&u,&v);  
            add(u,v);  
            add(v,u);  
        }  
        int tt;  
        for(int i=0; i<m; i++)  
        {  
            struct 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,tt);  
                }  
            }  
        }  
        bfs(t);  
        cout<<endl;  
    }  
    return 0;  
}