图的邻接表：广度优先遍历

最新推荐文章于 2022-10-21 10:20:13 发布
最新推荐文章于 2022-10-21 10:20:13 发布
阅读量2.7k 收藏 9
点赞数 1
分类专栏： 我的dhu记录 文章标签： 大数据 c++ 数据结构 宽度优先 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nameofworld/article/details/125616306
版权

图的邻接表：广度优先遍历

作者: 冯向阳时间限制: 1S章节: DS:图

截止日期: 2022-06-30 23:55:00

问题描述 :

目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。

内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。）

（2）设计并实现一个算法，应用递归的程序设计方法，对一个已存在的图进行广度优先遍历（BFS)，并输出遍历的顶点线性序列。遍历的起点通过输入指定。注意：遍历时，仅从该点出发遍历整个图，如果图不连通，则只遍历一个子图。图的存储结构采用邻接表。将其加入到ADT中。

注意：DG（有向图）, DN（有向网）, UDG（无向图）, UDN（无向网）

参考函数原型：

//BFS遍历 

template<class TypeOfVer, class TypeOfEdge>

void adjlist_graph<TypeOfVer, TypeOfEdge>::BFS_Traverse(int u);

图的邻接表模板类原型参考如下：

/* 边表的结点定义 */

template<class TypeOfEdge>

struct edgeNode

{

    int data;

    TypeOfEdge weight;

    edgeNode<TypeOfEdge> *next;

    edgeNode(const int &d, edgeNode<TypeOfEdge> *ptr = NULL) //构造函数，用于构造其他结点（无权图） 

    //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面

    {

        next = ptr;

        data = d;

    }

    edgeNode(const int &d, const TypeOfEdge &w, edgeNode<TypeOfEdge> *ptr = NULL) //构造函数，用于构造其他结点（带权图） 

    //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面

    {

        next = ptr;

        data = d;

        weight = w;

    }

    int getData(){ return data;}  //取得结点的序号（顶点集） 

    TypeOfEdge getWeight(){ return weight;}  //取得边集中对应边的权值 

    void SetLink( edgeNode<TypeOfEdge> *link ){ next = link; }  //修改结点的next域 

    void SetData( int value ){ data = value; }   //修改结点的序号（顶点集） 

    void SetWeight(TypeOfEdge value ){ weight = value; }   //修改边集中对应边的权值   

};

//图的邻接表类

template<class TypeOfVer, class TypeOfEdge>

struct verNode

{

    TypeOfVer ver;

    edgeNode<TypeOfEdge> *head;

    

    verNode(edgeNode<TypeOfEdge> *h = NULL){head = h;} 

    TypeOfVer getVer(){ return ver;}  //取得结点值（顶点集） 

    edgeNode<TypeOfEdge> *getHead(){ return head;}  //取得对应的边表的头指针 

    void setVer(TypeOfVer value){ ver = value;}  //设置结点值（顶点集） 

    void setHead(edgeNode<TypeOfEdge> *value){ head = value;}  //设置对应的边表的头指针

};

template <class TypeOfVer, class TypeOfEdge>

class adjlist_graph{

    private:

       int Vers;           //顶点数 

       int Edges;          //边数 

       verNode<TypeOfVer,TypeOfEdge> *verList;

       

       string GraphKind;     //图的种类标志 

       

       bool Delete_Edge( int u, int v ); 

       bool DFS(int u, int &num, int visited[]); //DFS遍历（递归部分）

    public:

       adjlist_graph( const string &kd, int vSize, const TypeOfVer d[]); //构造函数构造一个只有结点没有边的图。 

       adjlist_graph( const string &kd, int vSize, int eSize, const TypeOfVer d[], int **e); 构造函数构造一个无权图。5个参数的含义：图的类型、结点数、边数、结点集和边集 

       adjlist_graph( const string &kd, int vSize, int eSize, const TypeOfVer d[], int **e, const TypeOfEdge w[]); //构造函数构造一个有权图。

       bool GraphisEmpty() { return Vers == 0; }  //判断图空否

       string GetGraphKind(){ return GraphKind; }

       bool GetVer(int u, TypeOfVer &data); //取得G中指定顶点的值 

       int GetFirstAdjVex(int u, int &v); //返回G中指定顶点u的第一个邻接顶点的位序（顶点集）。若顶点在G中没有邻接顶点，则返回-1

       int GetNextAdjVex(int u, int v, int &w); //返回G中指定顶点u的下一个邻接顶点（相对于v）的位序（顶点集）。若顶点在G中没有邻接顶点，则返回false

       bool PutVer(int u, TypeOfVer data); //对G中指定顶点赋值 

       bool InsertVer(const TypeOfVer &data); //往G中添加一个顶点 

       int LocateVer(TypeOfVer data); //返回G中指定顶点的位置 

       bool ExistEdge(int u, int v);

       bool PrintVer();  //输出顶点集 

       bool PrintAdjList();  //输出邻接矩阵 

       int GetVerNum(){ return Vers;}    //取得当前顶点数 

       int GetEdgeNum(){ return Edges;}  //取得当前边数 

       bool Insert_Edge(int u, int v); //无权图插入一条边

       bool Insert_Edge(int u, int v, TypeOfEdge w); //有权图插入一条边

       bool DeleteVer(const TypeOfVer &data); //往G中删除一个顶点 

       bool DeleteEdge( int u, int v ); //删除边 (外壳：有向（删除1条边）， 无向（删除2条边））

       void DFS_Traverse(int u); //DFS遍历（外壳部分）

       void BFS_Traverse(int u); //BFS遍历

       ~adjlist_graph(); //析构函数 

};

输入说明 :

建图的输入数据格式参见建图的算法说明。（以无权图为例）

第一行：图的类型

第二行：结点数

第三行：结点集

第四行：边数

第五行：边集

第六行：起始顶点的位序

输出说明 :

第一行：顶点集

第二行：邻接表

空行

第三行：BFS遍历序列（结点之间用->分隔）

输入范例 :

UDG
8
V1 V2 V3 V4 V5 V6 V7 V8
8
0 1
0 2
1 3
1 4
2 5
2 6
3 7
4 7
5

输出范例 :

V1 V2 V3 V4 V5 V6 V7 V8
V1->2->1->nullptr
V2->4->3->0->nullptr
V3->6->5->0->nullptr
V4->7->1->nullptr
V5->7->1->nullptr
V6->2->nullptr
V7->2->nullptr
V8->4->3->nullptr

V6->V3->V7->V1->V2->V5->V4->V8

#include<iostream>
#include<queue>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;
int flag = 0,flag2=0;
int cun[1000]= {0};
template<class TypeOfEdge>
struct Edge
{
    int vex;
    TypeOfEdge weight;
    struct Edge* next=NULL;
} ;
template<class TypeOfVer,class TypeOfEdge>
struct Ver
{
    string ver;
    Edge<TypeOfEdge>* next=NULL;
} ;
template<class TypeOfVer,class TypeOfEdge>
struct Graph
{
    Ver<TypeOfVer,TypeOfEdge> AdjList[100];
    int vnum;
    int bnum;
    void ADDUDN(Graph<TypeOfVer,TypeOfEdge> &G);
    void AWeight(Graph<TypeOfVer,TypeOfEdge>& G);
    void creatUDN(Graph<TypeOfVer,TypeOfEdge> &G);
    void creatDG(Graph<TypeOfVer,TypeOfEdge> &G);
    int findvex(Graph<TypeOfVer,TypeOfEdge> *G,string v);
    void DFS(Graph<TypeOfVer,TypeOfEdge>&G,int num);
    void BFS(Graph<TypeOfVer,TypeOfEdge>&G,int num);
} ;

template<class TypeOfVer,class TypeOfEdge>
void Graph<TypeOfVer,TypeOfEdge>::creatUDN(Graph &G)
{
	cin >>G.vnum ;
	for (int i = 0; i <G.vnum; i++)
	{
		cin >> G.AdjList[i].ver;
	}
	cin >> G.bnum;
	for (int i = 0; i < G.bnum; i++)
	{
		int x1;
		int x2;
		cin >> x1 >> x2;
		Edge<TypeOfEdge>* pa = new Edge<TypeOfEdge>;
		pa->vex = x2;
		 pa->next= G.AdjList[x1].next ;
		G.AdjList[x1].next = pa;
		Edge<TypeOfEdge>* pb = new Edge<TypeOfEdge>;
		pb->vex = x1;
		 pb->next= G.AdjList[x2].next ;
		G.AdjList[x2].next = pb;
	}
}
template<class TypeOfVer,class TypeOfEdge>
void Graph<TypeOfVer,TypeOfEdge>::creatDG(Graph &G)
{
    cin >> G.vnum;
    for (int i = 0; i < G.vnum; i++)
    {
        cin >> G.AdjList[i].ver;
    }
    cin >> G.bnum;
    for (int i = 0; i < G.bnum; i++)
    {
        int x1;
        int x2;
        cin >> x1 >> x2;
        //cun[i][0] = x1;
        //cun[i][1] = x2;
        Edge<TypeOfEdge>* pa = new Edge<TypeOfEdge>;
        pa->vex = x2;
        pa->next=G.AdjList[x1].next;
        G.AdjList[x1].next = pa;
    }
}

template<class TypeOfVer,class TypeOfEdge>
void Graph<TypeOfVer,TypeOfEdge>::BFS(Graph<TypeOfVer,TypeOfEdge>&G,int num)
{
	queue<int> Q;
	Q.push(num);
	cun[num] = 1;
	cout << G.AdjList[num].ver ;
	Edge<TypeOfEdge>*pa = G.AdjList[num].next;
	while (!Q.empty())
	{
		int xx = Q.front();
		Q.pop();
		pa=G.AdjList[xx].next;
		while (pa)
		{
			if (cun[pa->vex] == 0)
			{
				cout<< "->"<< G.AdjList[pa->vex].ver;
				cun[pa->vex] = 1;
				Q.push(pa->vex);
			}
			pa = pa->next;
		}
	}
}
template<class TypeOfVer,class TypeOfEdge>
int Graph<TypeOfVer,TypeOfEdge>::findvex(Graph *G,string v)
{
    int i;
    for(i=0; i<G->vnum; i++)
    {
        if(v==G->AdjList[i].ver)
        {
            return i;
        }
    }
    return -1;
}
int main()
{
    string kind;
    cin >> kind;
    Graph<char,int> G;
    if (kind == "DN")
    {
        int flag = 0;
        G.creatDG(G);
        int num;
        cin>>num;
        for (int w = 0; w < G.vnum; w++)
        {
            if (flag == 1)
            {
                cout << " ";
            }
            flag = 1;
            cout << G.AdjList[w].ver;
        }
        cout << endl;
        for (int m = 0; m < G.vnum; m++)
        {
            cout << G.AdjList[m].ver;
            Edge<int>* pa =G.AdjList[m].next;
            while (pa)
            {
                cout << "->"<< pa->vex ;
                pa = pa->next;
            }
            if (pa == NULL)
            {
                cout << "->" << "nullptr" << endl;
            }
        }
        cout<<endl;
        G.BFS(G,num);
    }
    else if (kind == "UDN")
    {
        G.creatUDN(G);
        int num;
        cin>>num;
        for (int w = 0; w < G.vnum; w++)
        {
            if (flag == 1)
            {
                cout << " ";
            }
            flag = 1;
            cout << G.AdjList[w].ver;
        }
        cout << endl;
        for (int m = 0; m < G.vnum; m++)
        {
            cout << G.AdjList[m].ver;
            Edge<int>* pa = G.AdjList[m].next;
            while (pa)
            {
                cout << "->"<< pa->vex ;
                pa = pa->next;
            }
            if (pa == NULL)
            {
                cout << "->" << "nullptr" << endl;
            }
        }
        cout<<endl;
        G.BFS(G,num);
    }
    else if(kind=="DG")
    {
        G.creatDG(G);
        int num;
        cin>>num;
        for (int w = 0; w < G.vnum; w++)
        {
            if (flag == 1)
            {
                cout << " ";
            }
            flag = 1;
            cout << G.AdjList[w].ver;
        }
        cout << endl;
        for (int m = 0; m < G.vnum; m++)
        {
            cout << G.AdjList[m].ver;
            Edge<int>* pa =G.AdjList[m].next;
            while (pa)
            {
                cout << "->"<< pa->vex ;
                pa = pa->next;
            }
            if (pa == NULL)
            {
                cout << "->" << "nullptr" << endl;
            }
        }
        cout<<endl;
        G.BFS(G,num);
    }
    else if(kind=="UDG")
    {
       G.creatUDN(G);
        int num;
        cin>>num;
        for (int w = 0; w < G.vnum; w++)
        {
            if (flag == 1)
            {
                cout << " ";
            }
            flag = 1;
            cout << G.AdjList[w].ver;
        }
        cout << endl;
        for (int m = 0; m < G.vnum; m++)
        {
            cout << G.AdjList[m].ver;
            Edge<int>* pa = G.AdjList[m].next;
            while (pa)
            {
                cout << "->"<< pa->vex ;
                pa = pa->next;
            }
            if (pa == NULL)
            {
                cout << "->" << "nullptr" << endl;
            }
        }
        cout<<endl;
        G.BFS(G,num);
    }
    return 0;
}

nameofworld
关注
专栏目录
6-1 邻接表存储图的广度优先遍历 （20 分）
12-21 3391
6-1邻接表存储图的广度优先遍历（20 分） 试实现邻接表存储图的广度优先遍历。 函数接口定义： void BFS ( LGraph Graph, Vertex S, void (*Visit)(Vertex) ); 其中LGraph是邻接表存储的图，定义如下： /* 邻接点的定义 */ typedef struct AdjVNode *Ptr...
数据结构 C 代码 7.2: 邻接表及广度优先遍历
m0_63288471的博客
05-31 863
一.邻接表 邻接表，存储方法跟树的孩子链表示法相类似，是一种顺序分配和链式分配相结合的存储结构。如这个表头结点所对应的顶点存在相邻顶点，则把相邻顶点依次存放于表头结点所指向的单向链表中。 对于无向图来说，使用邻接表进行存储也会出现数据冗余，表头结点A所指链表中存在一个指向C的表结点的同时，表头结点C所指链表也会存在一个指向A的表结点。[1] 注意： n个顶点e条边的无向图的邻接表表示中有n个顶点表结点和2e个边表结点。(换句话说，每条边（i,j）在邻接表中出现两次：一次在关于i的邻接表中，另一次在关于j的.
邻接表及广度优先遍历
weixin_61023150的博客
05-30 2564
写在前面—— 本文主要是在记录进一步学习图结构的一些心得。 1.邻接表 邻接表是由每个顶点以及它的相邻顶点组成的。前一章我们知道了可以用邻接矩阵表示了图结构，但是它有一个致命的缺点，那就是矩阵中存在着大量的0，这在程序中会占据大量的内存。所以我们采用了邻接表的方法，从而很好的来解决邻接矩阵的缺陷。 2.代码实现 #include <stdio.h> #include <malloc.h> #define QUEUE_SIZE 10 int* visitedPtr..
邻接表—深度优先遍历
wh1236666的博客
12-15 1万+
深度优先遍历和广度优先遍历的参考知识点：https://blog.csdn.net/a2217018103/article/details/90678830 下面是使用邻接表做出的深度优先遍历案例： #include<stdlib.h> #include<stdio.h> #include<malloc.h> #include<string.h> //图的邻接表类型定义 typedef char VertexType[4]; typedef char Info
6-2 邻接表存储图的广度优先遍历 (20分)
xxxibgdrgn博客
11-10 1万+
试实现邻接表存储图的广度优先遍历。 函数接口定义： void BFS ( LGraph Graph, Vertex S, void (*Visit)(Vertex) ); 其中LGraph是邻接表存储的图，定义如下： /* 邻接点的定义 */ typedef struct AdjVNode *PtrToAdjVNode; struct AdjVNode{ Vertex AdjV; /* 邻接点下标 */ PtrToAdjVNode Next; /* 指向下一个邻接点的指针
广度优先遍历（邻接表存储图）
ml29895063的博客
04-02 6453
广度优先遍历（邻接表存储图）
邻接表与广度优先遍历_广度优先遍历_邻接表_广度优先_
10-01
邻接表和广度优先遍历（BFS）是处理图的两种常见方法。本文将详细讲解这两个概念以及如何在Visual Studio环境中实现基于邻接表的广度优先遍历，并利用队列这一数据结构来辅助这一过程。 首先，邻接表是图的一种存储...
C++实现图的邻接表存储和广度优先遍历实例分析
12-26
本文实例讲述了C++实现图的邻接表存储和广度优先遍历方法。分享给大家供大家参考。具体如下： 示例：建立如图所示的无向图 由上图知，该图有5个顶点，分别为a,b,c,d,e,有6条边. 示例输入（按照这个格式输入）： 5 6...
邻接表：深度优先遍历和广度优先遍历
小龙虾
04-29 9922
9天没有摸C语言，手很生啊！唉，考试终于结束了，就剩三门了。算法、数据结构太重要了，不要忽视啊！#include &lt;bits/stdc++.h&gt; using namespace std; #define MAXSIZE 100 int v[MAXSIZE];//标志位，判断该结点有没有被访问 typedef struct ArcNode //定义表节点 { int adjve...
邻接表表示的图的广度优先遍历
12-18
《数据结构与算法（C++版）》先关 邻接表表示的图的广度优先遍历的动画演示
4.4.3邻接表的广度优先遍历
qq_43192537的博客
11-13 770
#include <bits/stdc++.h> #include "Graph.cpp" using namespace std; void BFS(ALGraph *G, int v) { // 邻接表的BFS算法 ArcNode *p; int w; int visited[MAXV]; queue<int> qu; // 定义存放访问过的顶点的标志数组 ...
图的广度优先遍历(邻接表)
热门推荐
t_wu的博客
04-13 2万+
1.广度优先遍历        图的广度优先遍历类似于数的层序遍历，它的思想是从一个顶点V0开始，辐射状地优先遍历其周围较广的区域。以上便是广度优先遍历的一次过程（没循环）for 循环存放顶点的数组        如果当前顶点值未被访问过                访问它并且将它对应的判断数组变为true                将它入队                        w...
Java邻接表广度优先搜索_邻接表的广度优先遍历(java版)
weixin_36231030的博客
02-25 293
package com.datastruct;import java.util.LinkedList;import java.util.Scanner;public classAlGraph {//边表节点private static classEdgeNode{int adjvex; //存储该顶点对应的下标intweight;EdgeNode next;}//顶点表结点private stat...
@【数据结构】（图-邻接表 广度优先遍历）
gsgs1234的博客
04-23 1605
@【数据结构】（图-邻接表 广度优先遍历） 采用邻接表来实现图的存储，并输入输出邻接表的信息，并用邻接表来实现图的广度优先遍历。 生成邻接表： #include<iostream> #include<iomanip> #include<stdio.h> #include<stdlib.h> #define MAX 1000 #define INF 6...
6-2 邻接表存储图的广度优先遍历 （20 分）
葉蕖的博客
11-12 6321
试实现邻接表存储图的广度优先遍历。 函数接口定义： void BFS ( LGraph Graph, Vertex S, void (*Visit)(Vertex) ); 其中LGraph是邻接表存储的图，定义如下： /* 邻接点的定义 */ typedef struct AdjVNode *PtrToAdjVNode; struct AdjVNode{ Vertex AdjV; ...
广度优先遍历（邻接表，邻接矩阵）
q322359的博客
10-21 7802
广度优先遍历（邻接表，邻接矩阵）
有向图邻接表的广度优先遍历
最新发布
05-28
下面是邻接表的广度优先遍历的代码实现（假设图的顶点从 0 到 n-1 编号）： ```python from collections import deque def bfs(adj_list, start): n = len(adj_list) visited = [False] * n q = deque() q....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值