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

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

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<iostream>
#include<queue>
#include<cstring>
using namespace std;

struct node
{
    int d;
    node *next;
}*graph[110];
int v[110];
void add(int u,int v)               //建表
{
    node *p=new node;
    p->d=v;
    p->next=graph[u]->next;
    graph[u]->next=p;
}
void g_sort(int k)                  //排序
{
    for(int i=0; i<k; i++)
        for(node *p=graph[i]->next; p; p=p->next)
            for(node *q=p->next; q; q=q->next)
            {
                if(p->d>q->d)
                {
                    int tmp=p->d;
                    p->d=q->d;
                    q->d=tmp;
                }
            }
}
void bfs(int t)                    //广度优先搜索
{
    queue<int >q;
    q.push(t);
    v[t]=1;
    cout<<t;
    while(!q.empty())
    {
        int p=q.front();
        q.pop();
        if(!v[p])
        {
            cout<<" "<<p;
            v[p]=1;
        }
        node *k=graph[p]->next;
        while(k)
        {
            if(!v[k->d])
            {
                q.push(k->d);
            }
            k=k->next;
        }
    }
}
int main()
{
    int n;
    cin>>n;
    for(int i=0; i<110; i++)            //申请内存
    {
        graph[i]=new node;
    }
    while(n--)
    {
        int k,m,t;
        cin>>k>>m>>t;
        for(int i=0; i<k; i++)         //清零
        {
            graph[i]->next=NULL;
        }
        memset(v,0,sizeof(v));
        for(int i=0; i<m; i++)
        {
            int u,v;
            cin>>u>>v;
            add(u,v);
            add(v,u);
        }
        g_sort(k);
        dfs(t);
        cout<<endl;
    }
    return 0;
}

這裡附加了使用優先隊列來模擬鄰接表，在輸入時優先隊列會自動排序。

#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
priority_queue<int ,vector<int>,greater<int> >que[110]; //优先队列,小的在队首，因为从队首出队
int v[110];

void bfs(int t)                    //广度优先搜索
{
    queue<int >q;
    q.push(t);
    v[t]=1;
    cout<<t;
    while(!q.empty())
    {
        int p=q.front();
        q.pop();
        if(!v[p])
        {
            cout<<" "<<p;
            v[p]=1;
        }

        while(!que[p].empty())
        {
            int k=que[p].top();
            if(!v[k])
            {
                q.push(k);
            }
            que[p].pop();
        }
    }
}
int main()
{
    int n;
    cin>>n;

    while(n--)
    {
        int k,m,t;
        cin>>k>>m>>t;
        for(int i=0;i<k;i++)
        while(!que[i].empty())
            que[i].pop();
        memset(v,0,sizeof(v));
        for(int i=0; i<m; i++)
        {
            int u,v;
            cin>>u>>v;
            que[u].push(v);
            que[v].push(u);
        }
        dfs(t);
        cout<<endl;
    }
    return 0;
}