图的深度、广度优先遍历算法（含无向图、有向图的构造）

于 2024-09-30 16:53:01 发布
阅读量418 收藏 10
点赞数 19
分类专栏： 数据结构 文章标签： 算法 深度优先遍历 广度优先 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kong08242022/article/details/142659738
版权

目录

算法逻辑可能并不严谨，欢迎各位大佬批评指正！

一、非递归实现深度优先遍历

1、算法思想

（1）算法思想：

  • 首先检查起始顶点的索引是否有效和图是否已经建立。
  • 使用栈来实现深度优先搜索，首先将起始顶点入栈，并将起始顶点标记为已访问。
  • 循环直到栈为空，每次取出栈顶顶点，打印并访问它的邻接顶点，并将未访问的邻接顶点入栈并标记为已访问。

（2）时间复杂度： O(V + E)
（3）空间复杂度： O(V)，其中V是顶点数，E是边数。

2、算法流程图

在这里插入图片描述

3、算法

//深度优先
void DFS(int start) {
    if (start < 0 || start >= numVertices) {
        cout << "起始顶点不在图形中" << endl;
        return;
    }

    if (checkGraphBuilt()) {
        vector<bool> visited(numVertices, false);
        stack<int> s;
        s.push(start);
        visited[start] = true;

        while (!s.empty()) {
            int current = s.top();
            s.pop();

            if (current < 0 || current >= numVertices) {
                continue;
            }

            printNode(current);

            for (auto node : adjList[current]) {
                if (!visited[node.dest]) {
                    s.push(node.dest);
                    visited[node.dest] = true;
                }
            }
        }
        cout << endl;
    }
}

二、广度优先遍历

1、算法思想

（1）算法思想：

  • 首先检查起始顶点的索引是否有效和图是否已经建立。
  • 使用队列来实现广度优先搜索，首先将起始顶点入队，并将起始顶点标记为已访问。
  • 循环直到队列为空，每次取出队首顶点，打印并访问它的邻接顶点，并将未访问的邻接顶点入队并标记为已访问。

（2）时间复杂度： O(V + E)
（3）空间复杂度： O(V)，其中V是顶点数，E是边数。

2、算法流程图

在这里插入图片描述

3、算法

//广度优先
void BFS(int start) {
    if (start < 0 || start >= numVertices) {
        cout << "起始顶点不在图形中" << endl;
        return;
    }

    if (checkGraphBuilt()) {
        vector<bool> visited(numVertices, false);
        queue<int> q;
        q.push(start);
        visited[start] = true;

        while (!q.empty()) {
            int current = q.front();
            q.pop();

            if (current < 0 || current >= numVertices) {
                continue;
            }

            printNode(current);

            for (auto node : adjList[current]) {
                if (!visited[node.dest]) {
                    q.push(node.dest);
                    visited[node.dest] = true;
                }
            }
        }
        cout << endl;
    }
}

三、附检测算法完整程序（含无向图、有向图的构造）

1、操作说明

  1. 根据菜单指示输入要进行的操作相应的数字

  2. 输入数字1将会输出已经构造好的无向网。

  3. 输入数字2将进入键盘输入有向图的操作，输入顶点个数（规定顶点是从0开始的数字，如：顶点个数为4，则顶点分别是0、1、2、3），输入边的起点和终点。
    在这里插入图片描述

  4. 输入数字3输出有向图

  5. 输入数字4输出无向图深度优先非递归遍历结果

  6. 输入数字5输出无向图广度优先遍历结果

  7. 输入数字6退出程序

2、测试结果图

  • 构建无向网

在这里插入图片描述

  • 构建有向图、输出邻接表

在这里插入图片描述

  • 深度优先非递归遍历、广度优先遍

在这里插入图片描述

3、完整代码

#include <iostream>
#include <vector>
#include <queue>
#include <stack>

using namespace std;

class Graph {
private:
    struct Node {
        int dest;
        Node(int d) : dest(d) {}
    };

    int numVertices;
    vector<vector<int>> adjMatrix;
    vector<vector<Node>> adjList;
    vector<vector<Node>> adjGraph;
    bool isDirected;
    bool isGraphBuilt;
public:
    Graph() : numVertices(0), isDirected(false), isGraphBuilt(false) {}
    //初始化图
    void initializeGraph(int n, bool directed) {
        numVertices = n;
        isDirected = directed;
        adjMatrix = vector<vector<int>>(numVertices, vector<int>(numVertices, 0));
        adjList = vector<vector<Node>>(numVertices);
        adjGraph = vector<vector<Node>>(numVertices);
        isGraphBuilt = true;
    }

    //将边添加到邻接矩阵中
    void addEdgeToMatrix(int src, int dest, int weight) {
        if (checkGraphBuilt() && checkVertexIndex(src) && checkVertexIndex(dest)) {
            if (src <= numVertices && dest <= numVertices) {
                adjMatrix[src][dest] = weight;
                if (!isDirected) {
                    adjMatrix[dest][src] = weight;
                }
            }
            else {
                cout << "顶点索引越界！" << endl;
            }
        }
    }

    //将边添加到邻接表中
    void addEdgeToAdjList(int src, int dest) {
        if (checkGraphBuilt() && checkVertexIndex(src) && checkVertexIndex(dest)) {
            if (src <= numVertices && dest <= numVertices) {
                if (!isDirected) {
                    adjList[src].push_back(Node(dest));
                    adjList[dest].push_back(Node(src));
                }
                else {
                    adjGraph[src].push_back(Node(dest));
                }
            }
            else {
                cout << "顶点索引越界！" << endl;
            }
            
        }
    }
    
    //打印无向网
    void printAdjMatrix() {
        if (checkGraphBuilt()) {
            cout << "无向网邻接矩阵表示：" << endl;
            for (int i = 0; i < numVertices; i++) {
                for (int j = 0; j < numVertices; j++) {
                    if (i < numVertices && j < numVertices) {
                        cout << adjMatrix[i][j] << " ";
                    }
                    else {
                        cout << "顶点索引越界！";
                    }
                }
                cout << endl;
            }
        }
    }
    //键盘输入有向图
    void buildAdjListFromInput() {
        if (checkGraphBuilt()) {
            int src, dest;
            cout << "请输入边的起点和终点 (格式: 起点 终点)，输入-1 -1结束输入：" << endl;
            while (true) {
                cin >> src >> dest;
                if (src == -1 && dest == -1) {
                    break;
                }
                if (checkVertexIndex(src) && checkVertexIndex(dest) && src <= numVertices && dest <= numVertices) {
                    addEdgeToAdjList(src, dest);
                }
                else {
                    cout << "无效的顶点索引！请重新输入：" << endl;
                }
            }
        }
    }

    //打印有向图的邻接表
    void printAdjList() {
        if (checkGraphBuilt()) {
            for (int i = 0; i < numVertices; ++i) {
                if (checkVertexIndex(i)) {
                    cout << "顶点 " << i << " 的邻接表: ";
                    for (auto node : adjGraph[i]) {
                        if (checkVertexIndex(node.dest)) {
                            printNode(node.dest);
                        }
                        else {
                            cout << "无效的顶点索引：" << node.dest;
                        }
                    }
                    cout << endl;
                }
                else {
                    cout << "无效的顶点索引：" << i << endl;
                }
            }
        }
    }

    //深度优先
    void DFS(int start) {
        if (start < 0 || start >= numVertices) {
            cout << "起始顶点不在图形中" << endl;
            return;
        }

        if (checkGraphBuilt()) {
            vector<bool> visited(numVertices, false);
            stack<int> s;
            s.push(start);
            visited[start] = true;

            while (!s.empty()) {
                int current = s.top();
                s.pop();

                if (current < 0 || current >= numVertices) {
                    continue;
                }

                printNode(current);

                for (auto node : adjList[current]) {
                    if (!visited[node.dest]) {
                        s.push(node.dest);
                        visited[node.dest] = true;
                    }
                }
            }
            cout << endl;
        }
    }

    //广度优先
    void BFS(int start) {
        if (start < 0 || start >= numVertices) {
            cout << "起始顶点不在图形中" << endl;
            return;
        }

        if (checkGraphBuilt()) {
            vector<bool> visited(numVertices, false);
            queue<int> q;
            q.push(start);
            visited[start] = true;

            while (!q.empty()) {
                int current = q.front();
                q.pop();

                if (current < 0 || current >= numVertices) {
                    continue;
                }

                printNode(current);

                for (auto node : adjList[current]) {
                    if (!visited[node.dest]) {
                        q.push(node.dest);
                        visited[node.dest] = true;
                    }
                }
            }
            cout << endl;
        }
    }
private:
    bool checkGraphBuilt() {
        if (!isGraphBuilt) {
            cout << "未建立图！" << endl;
            return false;
        }
        return true;
    }

    bool checkVertexIndex(int index) {
        if (index < 0 || index >= numVertices) {
            cout << "无效的顶点索引！" << endl;
            return false;
        }
        return true;
    }

    void printNode(int node) {
        cout << "-> " << node;
    }
};
int main() {
    Graph graph;
    int choice;
    int numVertices = 0;
    bool isDirected = false;

    while (1) {
        cout << "--------菜单--------" << endl;
        cout << "1. 构造无向网" << endl;
        cout << "2. 键盘输入有向图" << endl;
        cout << "3. 输出邻接表" << endl;
        cout << "4. 无向图的深度优先非递归遍历" << endl;
        cout << "5. 无向图的广度优先遍历" << endl;
        cout << "6. 退出程序" << endl;
        cout << "请输入选项：";
        cin >> choice;

        switch (choice) {
        case 1:
            numVertices = 4;
            isDirected = false;
            graph.initializeGraph(numVertices, isDirected);
            graph.addEdgeToMatrix(0, 1, 1);
            graph.addEdgeToMatrix(0, 2, 2);
            graph.addEdgeToMatrix(1, 2, 3);
            graph.addEdgeToMatrix(2, 3, 4);
            graph.printAdjMatrix();
            break;
        case 2:
            cout << "请输入顶点个数（规定顶点是从0开始的数字，如：顶点个数为4，则顶点分别是0、1、2、3）: ";
            cin >> numVertices;
            isDirected = true;
            graph.initializeGraph(numVertices, isDirected);
            graph.buildAdjListFromInput();
            break;
        case 3:
            graph.printAdjList();
            break;
        case 4:
            numVertices = 4;
            isDirected = false;
            graph.initializeGraph(numVertices, isDirected);
            graph.addEdgeToAdjList(0, 1);
            graph.addEdgeToAdjList(0, 2);
            graph.addEdgeToAdjList(1, 2);
            graph.addEdgeToAdjList(2, 3);
            cout << "深度优先非递归遍历结果：" << endl;
            graph.DFS(0);
            break;
        case 5:
            numVertices = 4;
            isDirected = false;
            graph.initializeGraph(numVertices, isDirected);
            graph.addEdgeToAdjList(0, 1);
            graph.addEdgeToAdjList(0, 2);
            graph.addEdgeToAdjList(1, 2);
            graph.addEdgeToAdjList(2, 3);
            cout << "广度优先遍历结果：" << endl;
            graph.BFS(0);
            break;
        case 6:
            return 0;
        default:
            cout << "无效的选项！" << endl;
            break;
        }
    }
    return 0;
}
阿语！
关注
专栏目录
C++构造无向图，邻接矩阵，深度优先遍历，广度优先遍历
qq_44757691的博客
12-14 6093
define MVNum 100 //最大顶点数//定义无向图邻接矩阵{//顶点表//邻接矩阵//图的当前定点数和边数};
无向图的创建和深度优先遍历，广度优先遍历
jialiang的博客
07-16 2729
声明：下面的代码只是一个最基础的实现，没有经过严格的测试 图有两种表示方式，一种是邻接矩阵（二维数组），另一种是邻接表（数组+链表）。 下面的例子是针对于邻接链表实现的 上面的两幅图，第一副是无向图，第二幅是用邻接链表表示的无向图。 代码如下： /** * 图用来表示多对多的关系，数组和链表有前驱和后继，可以认为是一对一的关系。树是一对多的关系。 * 图的基本元素：顶点，边，路径，有向图，无向图，带权图（又称之为网）,其他概念参考：https://www.cnblogs.com.
构造无向图，进行深度优先遍历和广度优先遍历
qq_65354503的博客
05-09 1353
当队列que不为空时，进行while循环：将队列que的队头元素输出，并利用for循环寻找邻接矩阵中第vex行是否有未被访问过的顶点，如果有，则入队，并且辅助数组vis中的值改为true。借用辅助数组vis，以便判断顶点是否已经遍历过，已被遍历过的元素为true，没有遍历过的为false。否则，继续深度遍历这个未被调用过的第i个顶点。再输入图中i个顶点和j个顶点相连，使矩阵中的第i行第j列和第j行第i列的值为1，表示两个顶点i和j相通，矩阵中其他元素的值为0，表示这两个顶点之间无线。
C++实现图的深度优先遍历和广度优先遍历
JMW1407的博客
09-24 1万+
图的深度优先遍历 图的深度优先遍历参考 图的深度优先遍历 参考 1、https://blog.csdn.net/todd911/article/details/9191481 2、https://blog.csdn.net/weixin_42109012/article/details/94199335
利用邻接矩阵进行的深度优先和广度优先遍历（含全部代码+图解）
热门推荐
Initial_Mind的博客
04-29 4万+
良苦用心
【数据结构与算法】图的深度优先和广度优先遍历
南瓜籽_的博客
02-07 3549
图的深度优先和广度优先遍历
图的实现及深度优先遍历和广度优先遍历
weixin_45843917的博客
08-10 5211
图 1为什么要有图？ 1、线性表局限于一个直接前驱和一个直接后继的关系 2、树也只能有一个直接前驱即父节点 3、当我们需要多对多的关系时，就需要图 2、图的基本介绍 1、图是一种数据和结构，其中节点可以具有多个或零个相邻元素。两个结点之间的连接称为边。结点可以称为顶点 3、图的基本概念 1、顶点（vertex) 2、边（edge） 3、路径 4、无向图：顶点之间的连接没有方向 5、有向图：顶点之间连接有方向 6、带权图：这种边带权值的图也叫网 4、图的表示方式 1、邻接矩阵 1、邻接矩阵：表示图形中顶
图(graph)的遍历-----广度优先遍历(BFS)
m0_73633088的博客
10-24 1万+
​ 广度优先搜索（Breadth First Search）简称广搜或者 BFS，是遍历图存储结构的一种算法，既适用于无向图（网），也适用于有向图（网）。 广度优先遍历是一种图和树的遍历策略，它的核心思想是从一个起始节点开始，访问其所有邻近节点，然后再按照相同的方式访问这些邻近节点的邻近节点。这种遍历方式类似于波纹在水面上扩散的过程。 ​
图的顺序存储及其深度优先遍历和广度优先遍历
qq_43666632的博客
09-21 1127
图的顺序存储及其广度深度优先遍历
邻接表或者邻接矩阵为存储结构实现连通无向图的深度优先和广度优先遍历
12-06
在这个程序设计任务中，我们需要实现的是连通无向图的深度优先遍历（DFS）和广度优先遍历（BFS），这两种遍历方法是图算法的基础。无向图指的是图中的边没有方向，即任意两个节点之间可以双向连接。 1. **邻接表和...
图文详解两种算法：深度优先遍历（DFS）和广度优先遍历（BFS）
WANGHAOXIN364的博客
03-26 3870
图文详解两种算法：深度优先遍历（DFS）和广度优先遍历（BFS） 阅读本文前，请确保你已经掌握了递归、栈和队列的基本知识，如想掌握搜索的代码实现，请确保你能够用代码实现栈和队列的基本操作。 深度优先遍历(Depth First Search, 简称 DFS) 与广度优先遍历(Breath First Search，简称 BFS)是图论中两种非常重要的算法，也是进行更高的算法阶段学习的最后一道门槛。搜索算法频繁出现在算法竞赛题中，尤其是深度优先搜索，在竞赛中，它是用来进行保底拿分的神器！ 本文将..
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1250
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
二叉树最小深度
2301_80161204的博客
09-27 439
25[0, 105]
189. 轮转数组（C++）
weixin_45813121的博客
09-25 449
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
时间序列分析算法
qq_58353992的博客
09-24 923
通信领域：网络流量预测、服务器负载预测等。
算法训练营打卡Day14
Zoe_igxgx的博客
09-25 241
题目1.226.翻转二叉树题目2.101. 对称二叉树。
算法：按既定顺序创建目标数组
最新发布
AWSDN的博客
09-29 128
本文主要介绍按既定顺序创建目标数组问题
python 实现linear discriminant analysis线性判别分析算法
luthane的博客
09-26 476
线性判别分析（Linear Discriminant Analysis，简称LDA）是一种用于降维和分类的监督学习算法。它通过最大化类间散度和最小化类内散度来找到最佳投影方向，使得不同类别的数据在新的空间中尽可能分开，同一类别的数据尽可能靠近。LDA的基本思想LDA的基本思想是将多维数据映射到低维空间，同时保留数据之间的类别差异。具体来说，LDA通过计算类内散度矩阵（描述同一类别内部数据的分布情况）和类间散度矩阵（描述不同类别之间的差异），然后求解这两个矩阵的广义特征值问题，找到最佳的投影方向。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值