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

最新推荐文章于 2022-11-13 01:22:48 发布

「已注销」

最新推荐文章于 2022-11-13 01:22:48 发布

阅读量2.5k

点赞数

分类专栏：集训 SDUT

本文链接：https://blog.csdn.net/juncoder/article/details/19498923

版权

SDUT 同时被 2 个专栏收录

40 篇文章 0 订阅

订阅专栏

集训

30 篇文章 0 订阅

订阅专栏

这篇博客主要介绍了数据结构实验中关于图论的部分，涵盖了基于邻接矩阵和邻接表的广度优先搜索（BFS）遍历方法。文章详细阐述了算法的时间限制和内存限制，并提供了示例输入、输出以及相关提示，帮助读者理解和实现BFS遍历。

摘要由CSDN通过智能技术生成

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

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的遍历结果。

示例输入

示例输出

0 3 4 2 5 1

提示

以邻接矩阵作为存储结构。

解题报告

用邻接矩阵把边的信息存下来，从开始的点出发，把与开始的点相连的点入队列，访问过的点设为1，防止再次访问。。。（bfs）

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <queue>
using namespace std;
int mmap[100][100];
int vv[100];
void bfs(int t,int n)
{
    queue<int>Q;
    Q.push(t);
    vv[t]=1;
    int f=1;
    int q;
    while(!Q.empty())
    {
        q=Q.front();
        Q.pop();
        if(f)
        {
            f=0;
            printf("%d",q);
        }
        else printf(" %d",q);
        for(int i=0;i<n;i++)//找与q点相连接的点
        {
            if(!vv[i]&&mmap[q][i])//mmap[q][i]==1表示q点与i点相连接，!vv[i]表示i点没有找过
            {
                Q.push(i);
                vv[i]=1;
            }
        }
    }
}
int main()
{
    int n,k,m,t;
    int i,j;
    int u,v;
    scanf("%d",&n);
    while(n--)
    {
        memset(mmap,0,sizeof(mmap));
        memset(vv,0,sizeof(vv));
        scanf("%d%d%d",&k,&m,&t);
        for(i=0;i<m;i++)
        {
            scanf("%d%d",&u,&v);
            mmap[u][v]=mmap[v][u]=1;
        }
        bfs(t,k);
    }
    return 0;
}

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

Time Limit: 1000MS Memory limit: 65536K

题目描述

输入

输出

输出有n行，对应n组输出，每行为用空格隔开的k个整数，对应一组数据，表示BFS的遍历结果。

示例输入

示例输出

0 3 4 2 5 1

提示

用邻接表存储。

解题报告

邻接表的链表挺像哈希的链地址法。。。把每个点相邻的点挂上链后，然后全部入队列。。。

这题要求遍历结点小的点，而挂点是头插法。。。必定是无序，可以先挂点后，对整条链进行排序，排完就可以入队列，保证有序，且点从小到大。

//#include <iostream>
//#include <stdlib.h>
//#include <stdio.h>
//#include <string.h>
//#include <queue>
//#define M 20
//#define swap(x,y,t) ((t)=(x),(x)=(y),(y)=(t))
//using namespace std;
//struct node
//{
//    int u,v;
//    node *next;
//}*head[M];
//int vv[M],f=1;
//int cmpp(const void *a,const void *b)
//{
//    return (*(int *)a-*(int *)b);
//}
//void add(int u,int v)
//{
//    node *p=new node;
//    p->v=v;
//    p->next=head[u];
//    head[u]=p;
//}
//int b[100],x[100];
//void bfs(int t)
//{
//    int q,k=0;
//    queue<int>Q;
//    Q.push(t);
//    vv[t]=1;
//    f=1;
//    while(!Q.empty())
//    {
//        q=Q.front();
//        Q.pop();
//        x[++k]=q;
//        int i=0;
//        for(node *p=head[q];p!=NULL;p=p->next)
//        {
//            if(vv[p->v]==0)
//            {
//                b[i++]=p->v;
//                vv[p->v]=1;
//            }
//        }
//        if(i>=1)qsort(b,i,sizeof(b[0]),cmpp);
//        for(int j=0;j<=i-1;j++)
//            Q.push(b[j]);
//    }
//    int j;
//    for( j=1;j<=k-1;j++)
//        printf("%d ",x[j]);
//    printf("%d",x[j]);
//}
//
//struct N
//{
//    int u,v;
//} num[100];
//int cmp(const void *a,const void *b)
//{
//    return (((N *)b)->v-((N *)a)->v);
//}
//int main()
//{
//    int n,k,m;
//    int i,j;
//    int u,v,t;
//    scanf("%d",&n);
//    while(n--)
//    {
//        scanf("%d %d %d",&k,&m,&t);
//        memset(head,NULL,sizeof(head));
//        memset(vv,0,sizeof(vv));
//        for(i=0; i<m; i++)
//        {
//            scanf("%d%d",&u,&v);
//            add(u,v);
//            add(v,u);
//        }
//        bfs(t);
//        printf("\n");
//    }
//    return 0;
//}
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <queue>
#define M 20
#define swap(x,y,t) ((t)=(x),(x)=(y),(y)=(t))
using namespace std;
struct node
{
    int u,v;
    node *next;
}*head[M];
int vv[M],f=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[100],x[100];
void bfs(int t)
{
    int q,k=0;
    queue<int>Q;
    Q.push(t);
    vv[t]=1;
    f=1;

    while(!Q.empty())
    {
        q=Q.front();
        Q.pop();
        if(f)
        {
            f=0;
            printf("%d",q);
        }
        else printf(" %d",q);
        for(node *p=head[q]; p!=NULL; p=p->next)
        {
            if(vv[p->v]==0)
            {
                Q.push(p->v);
                vv[p->v]=1;
            }
        }
    }
}

struct N
{
    int u,v;
} num[100];

int main()
{

    int i,j;
    int u,v,t;
    scanf("%d",&n);
    while(n--)
    {
        scanf("%d %d %d",&k,&m,&t);
        memset(head,NULL,sizeof(head));
        memset(vv,0,sizeof(vv));
        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++)//对邻接链表排序
        {
            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);
        printf("\n");
    }
    return 0;
}