脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → C 语言 → C++ DFS BFS

C++实现图的遍历算法(DFS,BFS)的示例代码

 更新时间：2022年07月25日 10:20:32   作者：小张﹉  
本文给大家带来的是图遍历的算法，DFS(深度优先遍历)，BFS(广度优先遍历)。这两个算法是比较重要和常用的算法，但是在图中的实现只是最基本的操作，快跟随小编一起学习一下吧

图的定义

图由顶点集V(G)和边集E(G)组成，记为G=(V,E)。其中E(G)是边的有限集合，边是顶点的无序对（无向图）或有序对（有向图）。对于有向图来说，E(G)是有向边（也称弧(Arc)）的有限集合，弧是顶点的有序对，记为<v,w>，v、w是顶点，v为弧尾（箭头根部），w为弧头（箭头处）。对于无向图来说，E(G)是边的有限集合，边是顶点的无序对，记为(v, w)或者(w, v)，并且(v, w)=(w,v)。

图的相关术语

①顶点(Vertex)：图中的数据元素。

②顶点v的度：与v相关联的边的数目；

③顶点v的出度：以v为起点有向边数；

④顶点v的入度：以v为终点有向边数。

⑤边：顶点之间的逻辑关系用边来表示，边集可以是空的。

⑥无向边(Edge)：若顶点V1到V2之间的边没有方向，则称这条边为无向边。

⑦无向图(Undirected graphs)：图中任意两个顶点之间的边都是无向边。（A,D）=（D,A）

⑧有向边：若从顶点V1到V2的边有方向，则称这条边为有向边，也称弧(Arc)。用<V1,V2>表示，V1为狐尾(Tail)，V2为弧头(Head)。（V1，V2）≠（V2，V1）。

⑨有向图(Directed graphs)：图中任意两个顶点之间的边都是有向边。

注意：无向边用“（）”，而有向边用“< >”表示。

⑩简单图：图中不存在顶点到其自身的边，且同一条边不重复出现。

⑪无向完全图：无向图中，任意两个顶点之间都存在边。

⑫有向完全图：有向图中，任意两个顶点之间都存在方向互为相反的两条弧。

⑬稀疏图：有很少条边。

⑭稠密图：有很多条边。

⑮权（Weight）：与图的边或弧相关的数。

⑯网（Network）：带权的图。

⑰连通图：图中任意两个顶点都是连通的。

⑱极大连通子图：该子图是G连通子图，将G的任何不在该子图的顶点加入，子图将不再连通。

⑲极小连通子图：该子图是G的连通子图，在该子图中删除任何一条边，子图都将不再连通。

图的创建(邻接矩阵)---结构体

typedef struct
{
    //用来存放顶点
    int vexs[MAX];
    //二维数组：用来存放两点之间的关系
    int arcs[MAX][MAX];
    //图的顶点数和边数
    int vexsum, arcsnum;
}AMGraph,*StrAMGraph;

图的创建(邻接矩阵)---邻接矩阵的创建

int locate(AMGraph&G, int n)
{
    for (int i = 0; i < G.vexsum; i++)
    {
        if (G.vexs[i] == n)
        {
            return i;
        }
    }
}
 
//创建邻接矩阵
void Creat(AMGraph&G)
{
    int v1 = 0, v2 = 0, w = 0;
    cin >> G.vexsum >> G.arcsnum;
    for (int i = 0; i < G.vexsum; i++)
    {
        cin >> G.vexs[i];
    }
    for (int i = 0; i < G.vexsum; i++)
    {
        for (int j = 0; j < G.vexsum; j++)
        {
            G.arcs[i][j] = 0;
        }
    }
    for (int k = 0; k < G.arcsnum; k++)
    {
        cin >> v1 >> v2 >> w;
        int i = locate(G, v1);
        int j = locate(G, v2);
        G.arcs[i][j] = w;
    }
}

图的创建(邻接表)---结构体

typedef struct ArcNode
{
    int Adjust;
    struct ArcNode *next;
}AcrNode,*StrAcrNode;
 
 
typedef struct
{
    int data;
    StrAcrNode next;
}HeadNode, *StrHeadNode;
 
 
typedef struct 
{
    HeadNode arr[MAX];
    int acsrnum, vexsnum;
}ALGraph, *StrALGraph;

图的创建(邻接表)---邻接表的创建

int locate1(ALGraph&G, int n)
{
    for (int i = 0; i < G.vexsnum; i++)
    {
        if (G.arr[i].data == n)
        {
            return i;
        }
    }
}
 
void CreatALGraph(ALGraph&G)
{
    int v1 = 0, v2 = 0, w = 0;
    cin >> G.vexsnum >> G.acsrnum;
    for (int i = 0; i < G.vexsnum; i++)
    {
        cin >> G.arr[i].data;
        G.arr[i].next = NULL;
    }
    for (int k = 0; k < G.acsrnum; k++)
    {
        cin >> v1 >> v2;
        int i = locate1(G, v1);
        int j = locate1(G, v2);
        StrAcrNode p1;
        p1 = new AcrNode;
        p1->next = G.arr[i].next;
    }
}

对邻接矩阵进行深度优先遍历

//对邻接矩阵进行深度优先遍历
void DFS(AMGraph&G, int n)
{
    cout << G.vexs[n] << " ";
    visit[n] = 1;
    for (int i = 0; i < G.vexsum; i++)
    {
        if (G.arcs[n][i] != 1 && visit[i] != 1)
        {
            DFS(G, G.arcs[n][i]);
        }
    }
}

对邻接矩阵进行广度优先遍历

queue<int> qu;
//对邻接矩阵进行广度优先遍历
void BFS(AMGraph&G, int n)
{
    cout << G.vexs[n] << " ";
    qu.push(n);
    while (!qu.empty())
    {
        int m = qu.front();
        qu.pop();
        for (int i = 0; i < G.vexsum; i++)
        {
            if (visit[i] != 1 && G.arcs[m][i] != 1)
            {
                cout << G.vexs[i] << " ";
                visit[i] = 1;
                qu.push(i);
            }
        }
    }
}

对邻接表进行深度优先遍历 

void DFS1(ALGraph&G, int n)
{
    cout << G.arr[n].data << " ";
    visit3[n] = 1;
    StrAcrNode p1;
    p1 = G.arr[n].next;
    while (p1)
    {
        int w = p1->Adjust;
        if (visit3[w] != 1)
        {
            DFS1(G, w);
        }
        p1 = p1->next;
    }
}
 
queue<int> qu1;

对邻接表进行广度优先遍历 

queue<int> qu1;
void BFS(ALGraph&G, int n)
{
    cout << G.arr[n].data << " ";
    visit4[n] = 1;
    qu1.push(n);
    StrAcrNode p1;
    p1 = G.arr[n].next;
    while (!qu1.empty())
    {
        qu1.pop();
        int w = p1->Adjust;
        while (p1)
        {
            if (visit4[w] != 1)
            {
                qu1.push(w);
                visit4[w] = 1;
            }
            p1 = p1->next;
        }
    }
}

整体代码

#include<iostream>
#include<queue>
using namespace std;
const int MAxInt = 10;
int visit[MAxInt];
 
typedef struct
{
    int vexs[MAxInt];
    int arcs[MAxInt][MAxInt];
    int arcnum, vexsnum;
}AMGraph;
 
int locate(AMGraph&G, int n)
{
    for (int i = 0; i < G.vexsnum; i++)
    {
        if (G.vexs[i] == n)
        {
            return i;
        }
    }
}
 
void Creat(AMGraph&G)
{
    int v1 = 0, v2 = 0, w = 0;
    cin >> G.vexsnum >> G.arcnum;
    for (int i = 0; i < G.vexsnum; i++)
    {
        cin >> G.vexs[i];
    }
    for (int i = 0; i < G.vexsnum; i++)
    {
        for (int j = 0; j < G.vexsnum; j++)
        {
            G.arcs[i][j] = MAxInt;
        }
    }
    for (int k = 0; k < G.arcnum; k++)
    {
        cin >> v1 >> v2 >> w;
        int i = locate(G, v1);
        int j = locate(G, v2);
        G.arcs[i][j] = w;
        G.arcs[j][i] = w;
    }
}
 
 
 
queue<int> qu;
void BFS(AMGraph G, int v)
{
    cout << G.vexs[v];
    qu.push(v);
    visit[v] = 1;
    while (!qu.empty())
    {
        int w = qu.front();
        qu.pop();
        for (int i = 0; i < G.vexsnum; i++)
        {
            if (visit[i] != 1 && G.arcs[w][i] != MAxInt)
            {
                cout << G.vexs[i] << " ";
                visit[i] = 1;
                qu.push(i);
            }
        }
    }
}
 
int main()
{
    AMGraph G;
    Creat(G);
    cout << "对图进行广度优先遍历的结果为" << endl;
    BFS(G, 1);
    return 0;
}

注意 ：这里的代码是创建一个邻接矩阵来对图进行广度优先遍历，对图进行深度优先遍历以及临界表实现对图进行广度优先遍历，对图进行深度优先遍历大家都可以通过上面的代码块进行自由组合实现，这里就不进行一一实现。

结果展示

以上就是C++实现图的遍历算法(DFS,BFS)的示例代码的详细内容，更多关于C++ DFS BFS的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • C++实现softmax函数的面试经验

    C++实现softmax函数的面试经验

    这篇文章主要为大家介绍了C++实现softmax函数的面试经验,有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
    2022-05-05
  • C++实现Dijkstra算法的示例代码

    C++实现Dijkstra算法的示例代码

    迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法。本文将用C++实现Dijkstra算法，需要的可以参考一下
    2022-07-07
  • 提高C++程序运行效率的10个简单方法

    提高C++程序运行效率的10个简单方法

    这篇文章主要介绍了提高C++程序运行效率的10个简单方法,包括了循环、变量、继承等等应用的技巧,非常具有实用价值,需要的朋友可以参考下
    2014-09-09
  • C++回溯与分支限界算法分别解决背包问题详解

    C++回溯与分支限界算法分别解决背包问题详解

    给定n种物品和一背包。物品i的重量是wi，其价值为vi，背包的容量为C。问应如何选择装入背包的物品，使得装入背包中物品的总价值最大？下面我们分别用回溯与分支限界方法解决
    2022-06-06
  • MFC列表控件CListCtrl使用方法示范

    MFC列表控件CListCtrl使用方法示范

    这篇文章主要介绍了MFC列表控件CListCtrl使用方法示范,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-07-07
  • C语言实现BF算法案例详解

    C语言实现BF算法案例详解

    这篇文章主要介绍了C语言实现BF算法案例详解,本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下
    2021-08-08
  • C语言入门篇--关键字static详解

    C语言入门篇--关键字static详解

    本篇文章是C语言系列基础篇，C语言中,static是用来修饰变量和函数:1.修饰局部变量–>静态局部变量2.修饰全局变量–>静态全局变量3.修饰函数–>静态函数
    2021-08-08
  • C语言实现宿舍管理系统课程设计

    C语言实现宿舍管理系统课程设计

    这篇文章主要为大家详细介绍了C语言实现宿舍管理系统课程设计，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2022-03-03
  • Qt QTableWidget 实现行选中及行悬浮高亮效果

    Qt QTableWidget 实现行选中及行悬浮高亮效果

    使用Qt开发中,实现表格的行选中和悬浮高亮效果是一个常见需求,但Qt自带的方法无法直接实现,解决方案是通过子类化QStyledItemDelegate并重写其paint函数来定制化绘制过程,本文给大家介绍Qt QTableWidget 实现行选中及行悬浮高亮效果,感兴趣的朋友一起看看吧
    2024-09-09
  • C语言版飞机大战游戏

    C语言版飞机大战游戏

    这篇文章主要为大家详细介绍了C语言版飞机大战游戏，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2020-12-12

最新评论