数据结构与算法之图的遍历

已于 2023-09-19 10:52:45 修改
阅读量364 收藏 3
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 动态规划 java
于 2023-09-19 10:42:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47225948/article/details/133017705
版权

数据结构与算法之图的遍历

图的遍历是指对图中所有结点和边进行一次且仅一次的访问操作。图的遍历可以分为深度优先遍历（DFS）和广度优先遍历（BFS）。

深度优先遍历采用栈实现，其基本思路是从图的某一结点出发，深度优先遍历该节点的所有邻接点，再依次对每个邻接点进行深度优先遍历。在遍历过程中，需要记录已经访问过的结点，避免重复访问。深度优先遍历是一种先纵向遍历到底再回溯的方法。

广度优先遍历采用队列实现，其基本思路是从图的某一结点出发，访问其所有邻接点，然后按照宽度遍历该结点的下一层邻接点。在遍历过程中，同样需要记录已经访问过的结点，避免重复访问。广度优先遍历是一种逐层遍历的方法，可以得到最短路径的长度。

图的遍历算法是图算法中最常用的算法之一，广泛应用于网络路由、迷宫寻路、社交网络分析等领域。

在这里插入图片描述


一、C 图的遍历 源码实现及详解

C语言中可以使用邻接矩阵或邻接表来表示图，不同的数据结构在遍历图的时候有着不同的算法实现。以下是邻接表表示图的遍历算法实现：

  1. 深度优先遍历（DFS）：
#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTICES 20

typedef struct node{
    int vertex;
    struct node* next;
} node;

int visited[MAX_VERTICES];

void DFS(node** adjacencyList, int vertex) {
    visited[vertex] = 1;
    printf("%d ", vertex);
    node* ptr = adjacencyList[vertex];
    while (ptr != NULL) {
        int u = ptr->vertex;
        if (visited[u] == 0) {
            DFS(adjacencyList, u);
        }
        ptr = ptr->next;
    }
}

int main() {
    node* adjacencyList[MAX_VERTICES];
    int noOfVertices, noOfEdges;
    printf("Enter the number of vertices in the graph: ");
    scanf("%d", &noOfVertices);
    printf("Enter the number of edges in the graph: ");
    scanf("%d", &noOfEdges);
    
    for (int i = 0; i < noOfVertices; i++) {
        adjacencyList[i] = NULL;
        visited[i] = 0;
    }
    
    int vertex1, vertex2;
    for (int i = 0; i < noOfEdges; i++) {
        printf("Enter vertices for edge %d: ", i + 1);
        scanf("%d%d", &vertex1, &vertex2);
        node* newNode1 = (node*) malloc(sizeof(node));
        newNode1->vertex = vertex2;
        newNode1->next = adjacencyList[vertex1];
        adjacencyList[vertex1] = newNode1;
        
        node* newNode2 = (node*) malloc(sizeof(node));
        newNode2->vertex = vertex1;
        newNode2->next = adjacencyList[vertex2];
        adjacencyList[vertex2] = newNode2;
    }

    int startingVertex = 0;
    printf("Depth First Traversal, starting from vertex %d: ", startingVertex);
    DFS(adjacencyList, startingVertex);
    printf("\n");

    return 0;
}
  1. 广度优先遍历（BFS）：
#include <stdio.h>
#include <stdlib.h>

#define MAX_VERTICES 20

typedef struct node{
    int vertex;
    struct node* next;
} node;

int visited[MAX_VERTICES];

void BFS(node** adjacencyList, int startingVertex) {
    visited[startingVertex] = 1;
    printf("%d ", startingVertex);
    int queue[MAX_VERTICES], front = -1, rear = -1;
    queue[++rear] = startingVertex;
    while (front != rear) {
        int u = queue[++front];
        node* ptr = adjacencyList[u];
        while (ptr != NULL) {
            int v = ptr->vertex;
            if (visited[v] == 0) {
                printf("%d ", v);
                visited[v] = 1;
                queue[++rear] = v;
            }
            ptr = ptr->next;
        }
    }
}

int main() {
    node* adjacencyList[MAX_VERTICES];
    int noOfVertices, noOfEdges;
    printf("Enter the number of vertices in the graph: ");
    scanf("%d", &noOfVertices);
    printf("Enter the number of edges in the graph: ");
    scanf("%d", &noOfEdges);
    
    for (int i = 0; i < noOfVertices; i++) {
        adjacencyList[i] = NULL;
        visited[i] = 0;
    }
    
    int vertex1, vertex2;
    for (int i = 0; i < noOfEdges; i++) {
        printf("Enter vertices for edge %d: ", i + 1);
        scanf("%d%d", &vertex1, &vertex2);
        node* newNode1 = (node*) malloc(sizeof(node));
        newNode1->vertex = vertex2;
        newNode1->next = adjacencyList[vertex1];
        adjacencyList[vertex1] = newNode1;
        
        node* newNode2 = (node*) malloc(sizeof(node));
        newNode2->vertex = vertex1;
        newNode2->next = adjacencyList[vertex2];
        adjacencyList[vertex2] = newNode2;
    }

    int startingVertex = 0;
    printf("Breadth First Traversal, starting from vertex %d: ", startingVertex);
    BFS(adjacencyList, startingVertex);
    printf("\n");

    return 0;
}

在这些算法实现中，我们使用了邻接表来表示图，并使用DFS和BFS算法遍历了图。DFS算法保证了对于每个节点，每个邻接边只被访问了一次，算法的时间复杂度为O(V + E)，其中V是顶点数，E是边数。BFS算法同样保证了每个邻接边只被访问了一次，并且在遍历过程中可以求出每个节点到起始节点的最短路径，算法的时间复杂度为O(V + E)。

在这里插入图片描述


二、C++ 图的遍历 源码实现及详解

以下是C++中图的遍历的源码实现及详解：

定义一个Graph类，包含以下成员变量和成员函数：

class Graph {
private:
    int V; //顶点数
    list<int>* adj; //邻接表

    //深度优先遍历
    void DFS(int v, bool visited[]);
public:
    Graph(int v);
    ~Graph();

    //添加边
    void addEdge(int v, int w);

    //广度优先遍历
    void BFS(int s);

    //深度优先遍历
    void DFS();
};

Graph类的构造函数和析构函数：

//构造函数
Graph::Graph(int v) {
    V = v;
    adj = new list<int>[v];
}

//析构函数
Graph::~Graph() {
    delete[] adj;
}

Graph类的addEdge函数，用于添加一条边：

void Graph::addEdge(int v, int w) {
    adj[v].push_back(w);
    adj[w].push_back(v);
}

Graph类的BFS函数，用于广度优先遍历：

void Graph::BFS(int s) {
    //创建一个标记数组，初始值都是false
    bool* visited = new bool[V];
    for (int i = 0; i < V; i++) {
        visited[i] = false;
    }

    //创建一个队列
    list<int> queue;

    //标记起点为访问过的，并将起点放入队列中
    visited[s] = true;
    queue.push_back(s);

    //遍历队列
    while (!queue.empty()) {
        //取出队列首元素并访问
        s = queue.front();
        cout << s << " ";
        queue.pop_front();

        //遍历邻接表，将未访问过的邻居放入队列中
        for (auto i = adj[s].begin(); i != adj[s].end(); i++) {
            if (!visited[*i]) {
                visited[*i] = true;
                queue.push_back(*i);
            }
        }
    }

    delete[] visited;
}

Graph类的DFS函数，用于深度优先遍历：

void Graph::DFS(int v, bool visited[]) {
    //标记当前点为已访问过
    visited[v] = true;
    cout << v << " ";

    //遍历邻接表，递归访问未访问过的邻居
    for (auto i = adj[v].begin(); i != adj[v].end(); i++) {
        if (!visited[*i]) {
            DFS(*i, visited);
        }
    }
}

void Graph::DFS() {
    //创建一个标记数组，初始值都是false
    bool* visited = new bool[V];
    for (int i = 0; i < V; i++) {
        visited[i] = false;
    }

    //遍历所有未访问过的点
    for (int i = 0; i < V; i++) {
        if (!visited[i]) {
            DFS(i, visited);
        }
    }

    delete[] visited;
}

以上就是C++中图的遍历的源码实现及详解。

在这里插入图片描述


三、java 图的遍历 源码实现及详解

图是一种非线性数据结构，它具有许多实际应用。图的遍历是指从指定的起始顶点开始访问图中的所有顶点。常用的两种遍历方式为深度优先遍历和广度优先遍历。下面分别介绍这两种遍历方式的源码实现及详解。

深度优先遍历（DFS）

深度优先遍历是一种先序遍历方式，即从起点开始，访问一条路径上的所有顶点直到无法继续为止，然后回溯到之前的顶点，继续访问其他路径。这种遍历方式通常使用递归实现。

以下是深度优先遍历的核心代码：

public void dfs(int v, boolean[] visited) {
    visited[v] = true;
    System.out.print(v + " ");
    for (int w : adj[v]) {
        if (!visited[w]) {
            dfs(w, visited);
        }
    }
}

其中，v表示当前顶点的编号，visited是一个布尔数组，表示每个顶点是否已经被访问过。adj是一个邻接表，表示各个顶点之间的关系。

具体实现过程如下：

  1. 将当前顶点v标记为已访问；
  2. 输出当前顶点v；
  3. 遍历v的所有邻居顶点w：
    1. 如果w未被访问过，则递归访问w。

使用样例：

public void testDfs() {
    Graph g = new Graph(5);
    g.addEdge(0, 1);
    g.addEdge(0, 2);
    g.addEdge(0, 4);
    g.addEdge(1, 3);
    g.addEdge(2, 3);
    g.addEdge(3, 4);
    g.dfs(0);
}

输出结果为：

0 1 3 2 4

广度优先遍历（BFS）

广度优先遍历是一种按层遍历方式，即从起点开始，先访问所有与其相邻的顶点，然后继续访问与这些顶点相邻的所有顶点，以此类推，直到遍历完所有顶点为止。这种遍历方式通常使用队列实现。

以下是广度优先遍历的核心代码：

public void bfs(int s) {
    boolean[] visited = new boolean[V];
    LinkedList<Integer> queue = new LinkedList<>();
    visited[s] = true;
    queue.add(s);
    while (queue.size() != 0) {
        s = queue.poll();
        System.out.print(s + " ");
        for (int w : adj[s]) {
            if (!visited[w]) {
                visited[w] = true;
                queue.add(w);
            }
        }
    }
}

其中，s表示起始顶点的编号，visited是一个布尔数组，表示每个顶点是否已经被访问过。adj是一个邻接表，表示各个顶点之间的关系。

具体实现过程如下：

  1. 将起始顶点s标记为已访问，并将其入队；
  2. 当队列不为空时，取出队首元素s，并输出；
  3. 遍历s的所有邻居顶点w：
    1. 如果w未被访问过，则将其标记为已访问，并将其入队。

使用样例：

public void testBfs() {
    Graph g = new Graph(5);
    g.addEdge(0, 1);
    g.addEdge(0, 2);
    g.addEdge(0, 4);
    g.addEdge(1, 3);
    g.addEdge(2, 3);
    g.addEdge(3, 4);
    g.bfs(0);
}

输出结果为：

0 1 2 4 3

以上是深度优先遍历和广度优先遍历的源码实现及详解。需要注意的是，在实际应用中，图的遍历可以使用多种数据结构和算法实现，具体实现方式需根据具体情况进行选择。

在这里插入图片描述





躺平的小懒猫
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之图的遍历算法
01-01
c++实现图的遍历算法，Visual c++6.0下调试通过 图的存储使用邻接表法
数据结构基础之图（中）：图的遍历算法
绝圣弃智-零的博客
11-05 646
转自：http://www.cnblogs.com/edisonchou/p/4676876.html   图（中）：图的遍历算法 上一篇我们了解了图的基本概念、术语以及存储结构，还对邻接表结构进行了模拟实现。本篇我们来了解一下图的遍历，和树的遍历类似，从图的某一顶点出发访问图中其余顶点，并且使每一个顶点仅被访问一次，这一过程就叫做图的遍历（Traversing Graph）。如果只访问图的...
图的遍历（完整代码）
help_child的博客
07-24 5104
代码实现功能： 1.利用图的邻接矩阵构造并输出图。 2.实现图的深度优先搜索遍历。 3.实现图的广度优先搜索遍历。 #include<stdio.h> #include<stdlib.h> #include<limits.h> #define INFINITY INT_MAX #define MAX_VERTEX_NUM 20 #define FALSE 0 #define TRUE 1 #define OK 1 #define ERROR -2 #define OVER
图的遍历算法
weixin_34307464的博客
10-01 93
遍历操作是图算法的基本操作，对于图的遍历，主要有两种，一种是深度遍历，一种是广度遍历。虽然这种操作很基本，但是稍微加一些其他的元素进去就能形成很有用的算法，比如加一些限制就可以变成深度或者广度搜索。 图遍历算法的特点是需要用一个visit数组保存各个节点是否已经被访问过的信息，对于深度遍历，一般都是递归操作，对于广度遍历，一般是用先入先出队列实现。下面是相应的代码，其他需要的头文件在之前的...
JavaScript数据结构与算法之二叉树遍历算法详解【先序、中序、后序】
10-17
主要介绍了JavaScript数据结构与算法之二叉树遍历算法,结合实例形式详细分析了javascript二叉树的定义及先序遍历、中序遍历、后序遍历等相关遍历操作实现技巧,需要的朋友可以参考下
Python数据结构与算法之二叉树结构定义与遍历方法详解
12-25
本文实例讲述了Python数据结构与算法之二叉树结构定义与遍历方法。分享给大家供大家参考，具体如下： 先序遍历，中序遍历，后序遍历 ，区别在于三条核心语句的位置 层序遍历 采用队列的遍历操作第一次访问根，在...
数据结构与算法之美.zip
最新发布
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
遍历列表集合：数据结构与算法详解.md
08-12
遍历算法是数据结构与算法的基础,掌握遍历对后续算法学习极为重要。 能学到什么: 通过学习可以全面掌握列表数据结构的特点,遍历算法的设计思想,循环与迭代器两种实现方式,时间复杂度分析,以及遍历在数据处理、查找...
【数据结构】基础：图的遍历实现（附C++源代码）
qq_66725576的博客
02-14 1651
摘要：将会在数据结构专题中开展关于图论的内容介绍，其中包括四部分，分别为图的概念与实现、图的遍历、图的最小生成树以及图的最短路径问题。本文将介绍图的遍历，分别为深度优先遍历和广度优先遍历，需要了解其实现实现与方法。
数据结构实验 图的遍历
10-23
图也是数据结构里的重要知识点，能够实现语言编写实现图的性质和操作，也需要有点语言功底啊。。。
图的遍历算法实现（深度和广度搜素）
11-26
图的遍历算法实现，使用深度优先搜索，实现深度优先搜索
实现图的遍历算法
热门推荐
xiezhi123456的博客
02-27 1万+
一、图的深度优先概述 图，就是由一些小圆点（称为顶点）和连接这些小圆点的直线（称为边）组成的。例如：                                                            上图是由五个顶点（编号为1、2、3、4、5）和五条边（1-2、1-3、1-5、2-4、3-5）组成。 现在从1号顶点开始遍历这个图（遍历指的是把每一个顶点都访问一次）。使用...
实现图的遍历
Shenrunchen的博客
12-02 825
实现图的深度优先遍历算法 实现图的广度优先遍历算法
《图论》——图的存储与遍历（Java）
weixin_33929309的博客
05-25 3164
一：图的分类 1：无向图 即两个顶点之间没有明确的指向关系，只有一条边相连，例如，A顶点和B顶点之间可以表示为 <A, B> 也可以表示为<B, A>，如下所示 2：有向图 顶点之间是有方向性的，例如A和B顶点之间，A指向了B，B也指向了A，两者是不同的...
数据结构：图的各种遍历算法实现
sinb妃的博客
01-09 2099
题目： 以0结点为起点实现上述图的深度优先和广度优先遍历算法； 思路： （1） 邻接矩阵深度搜索：从起始点开始循环，对下一层第一个点开始往下搜索，穷尽后，再返回上一层的第n个点搜索。如果该点没被访问过，则输出； （2） 邻接矩阵广度搜索：建立队列，把起始点放入队列，建立循环，把队首的所有边连接的结点放入队列，如果队首未被访问则输出并弹出，直到队空退出。 （3） 邻接表深度搜索：从起始点开始循环，对...
算法（图的遍历）
weixin_50340097的博客
02-17 215
初识图 图：图简单来说，是由一些小圆点（称为顶点）和链接这些小圆点的直线（称为边）组成的。 时间戳:按照图中顶点访问顺序，我们把这些访问顺序称之为时间戳。 那么遍历的方式，我们在之前已经学过了广度优先搜索和深度优先搜索，现在来复习一下： 深度优先搜索：首先从一个未走到过的顶点作为起始顶点，沿着这个顶点的边去尝试访问其他未走到过的顶点，每走到一个顶点，就沿着这个顶点边去走其他未走到过的顶点，直到到达最末端，然后返回，尝试从别的边来访问其他的点，直到又到达另外一个末端，一次往复，直到整个图都没有了可走的边为止。
数据结构实践——操作用邻接表存储的图
ytdxtzj的博客
11-23 421
/* * Copyright (c) 2015, 烟台大学计算机与控制工程学院 * All rights reserved. * 文件名称： main.cpp,graph.h,graph.cpp * 作者：唐子健* 完成日期：2015年11月23日 * 版本号：codeblocks * * 问题描述: 输出出图G中每个顶点的出度 * 输入描述： 无 * 程序输出： 见运行结果
数据结构 图的广度优先遍历算法的实现
03-08
广度优先遍历算法的实现可以使用队列来实现。首先将起始节点加入队列中，然后从队列中取出一个节点，将其所有未访问过的邻居节点加入队列中，并标记为已访问。重复这个过程，直到队列为空。这样就可以按照广度优先的顺序遍历整张图。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值