数据结构学习笔记（六）之 无向图的遍历

最新推荐文章于 2024-07-09 16:42:24 发布
最新推荐文章于 2024-07-09 16:42:24 发布
阅读量1.4k 收藏 21
点赞数 2
分类专栏： 学习笔记 文章标签： 无向图的遍历 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42327790/article/details/103120803
版权

欢迎移步博主小站：白亮吖雅黑丫の小站

图的遍历（一）之 无向图

无向图的两种遍历算法的实现

简介

图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为

G = ( V , E ) G = (V,E) G=(V,E)

如果图的任意两个顶点之间的边都是无向边，则称该图为无向图,否则称该图为有向图。

图的两种遍历算法思想

  • 深度优先遍历算法思想
    （1）访问顶点v；
    （2）从v的未被访问的邻接点中选取一个顶点w，从w出发进行深度优先遍历；
    （3）重复上述两步，直至图中所有和v有路径相通的顶点都被访问到
  • 广度优先遍历算法思想
    （1）访问顶点v；
    （2）依次访问v的各个未被访问的邻接点v1，v2，v3…
    （3）分别从v1，v2，v3…出发依次访问它们未被访问的邻接点，并使先被访问顶点的邻接点先于后被访问顶点的邻接点被访问。直至图中所有与顶点v有路径相通的顶点都被访问到。

以下面这个无向图为例进行实现
在这里插入图片描述

采用邻接矩阵存储

图的邻接矩阵存储也称为数组表示法，其方法是用一个以为数组存储图中顶点的信息，用一个二维数组存储图中边的信息，存储顶点之间临界关系的二维数组称为邻接矩阵。

为了省时间（其实是自己懒 ），此处省略邻接矩阵的构造过程，采用手动写入边集和点集构建该无向图。

		//手动构造图的点集和边集
        //点集
        int[] vector = {
                0,1,2,3,4,5
        };
        //边集
        int[][] arc ={
                {0,1,1,1,1,0},
                {1,0,0,0,1,0},
                {1,0,0,0,1,0},
                {1,0,0,0,0,0},
                {1,1,1,0,0,1},
                {0,0,0,0,1,1}
        };
        //记录是否访问
        int[] visited = {
                0,0,0,0,0,0
        };

深度优先遍历（递归实现）

 	//图的深搜DFS,递归
    public static void DFS(int[] vector, int[] visited, int[][] arc,int i){
        //访问结点并标记
        System.out.println(vector[i]);
        visited[i]=1;
        for (int j = 0;j<vector.length; ++j){
            if (visited[j]==0 && arc[i][j]==1)
                DFS(vector,visited,arc,j);
        }
    }

深度优先遍历 （非递归实现）

//图的深搜DFS ,非递归
    public static void DFS(int[] vector, int[] visited, int[][] arc){
        //访问第一个顶点并入栈
        System.out.println(vector[0]);
        Stack<Integer> stack = new Stack<Integer>();
        stack.push(0);
        visited[0] = 1;
        while(!stack.isEmpty()){
            //获取栈顶元素
            int x = stack.peek();
            //标志位
            boolean flag = false;
            for (int i = 0; i<vector.length;++i){
                if (visited[i]==0 && arc[x][i]==1){
                    System.out.println(vector[i]);
                    //入栈
                    stack.push(i);
                    //更改访问位,标志位
                    visited[i] = 1;
                    flag = true;
                    break;
                }
            }
            //出栈
            if (!flag)
                stack.pop();
        }
    }

广度优先遍历

//图的广搜BFS,非递归
    public static void BFS(int[] vector, int[] visited, int[][] arc){
        Queue<Integer> queue = new LinkedList<Integer>();
        //第一个顶点入队
        queue.offer(0);
        while (!queue.isEmpty()){
            //出队
            int x = queue.poll();
            //访问结点并标记
            System.out.println(vector[x]);
            visited[x] = 1;
            //寻找连通的结点并入队
            for (int i = 0; i<vector.length;++i){
                if (visited[i]==0 && arc[x][i]==1){
                    queue.offer(i);
                    visited[i] = 1;
                }
            }
        }
    }

采用邻接表存储

图的邻接表存储是一种顺序存储与链接存储相结合的存储方法，类似于数的孩子链表表示法。对于图的每个顶点v，将所有邻接于v的顶点链成一个单链表，称为顶点v的边表（对于有向图则称为出边表）。

顶点类：

/**
 * @Author zbl
 * @Date: 2019/11/18/ 17:59
 * @Description
 */

//顶点结点
public class VertexNode{
    public int vertex;
    public ArcNode firstEdge;
}

边表类：

/**
 * @Author zbl
 * @Date: 2019/11/18/ 17:12
 * @Description
 */

//边结点
public class ArcNode {
    //邻接点域
    public int adjvex;
    public ArcNode next;
    public ArcNode(){}
    public ArcNode(int adjvex,ArcNode arcNode) {this.adjvex=adjvex;this.next=arcNode;}
}

以下面这个无向图为例进行实现
在这里插入图片描述

  • 该无向图的DFS访问顺序：V0->V1->V4->V2->V3
  • 该无向图的BFS访问顺序：V0->V1->V2->V3->V4

为了省时间（其实是自己懒 ），此处省略邻接表的构造过程，采用手动写入边集和点集构建该无向图。

		//手动构造图的点集和边集
		//手动构造点集和边集
        VertexNode[] vertex = new VertexNode[5];
        for (int i = 0;i<vertex.length;++i){
            vertex[i] = new VertexNode();
            vertex[i].vertex=i;
        }


        ArcNode V03 = new ArcNode(3,null);
        ArcNode V02 = new ArcNode(2,V03);
        ArcNode V01 = new ArcNode(1,V02);
        ArcNode V12 = new ArcNode(4,null);
        ArcNode V11 = new ArcNode(0,V12);
        ArcNode V22 = new ArcNode(3,null);
        ArcNode V21 = new ArcNode(0,V22);
        ArcNode V32 = new ArcNode(2,null);
        ArcNode V31 = new ArcNode(0,V32);
        ArcNode V41 = new ArcNode(1,null);

        vertex[0].firstEdge=V01;
        vertex[1].firstEdge=V11;
        vertex[2].firstEdge=V21;
        vertex[3].firstEdge=V31;
        vertex[4].firstEdge=V41;

        for(int i = 0; i<visited.length; ++i)
            visited[i] = 0;

深度优先遍历（递归实现）

 	/**
    * @Description: 图的深搜DFS，邻接矩阵存储，递归
    * @Param: [vertex, visited, i]
    * @return: void
    * @Author: zbl
    * @Date: 2019/11/18
    */
    public static void DFS(VertexNode[] vertex,int[] visited,int i){
        System.out.println(vertex[i].vertex);
        visited[i]=1;
        ArcNode tmp = vertex[i].firstEdge;
        while(tmp != null){
            int j = tmp.adjvex;
            if(visited[j]==0)
                DFS(vertex,visited,j);
            tmp = tmp.next;
        }
    }

深度优先遍历 （非递归实现）

/**
     * @Description: 图的深搜DFS，邻接矩阵存储，非递归
     * @Param: [vertex, visited]
     * @return: void
     * @Author: zbl
     * @Date: 2019/11/18
     */
    public static void DFS(VertexNode[] vertex,int[] visited){
        Stack<Integer> stack = new Stack<Integer>();
        //访问第一个顶点并入栈
        System.out.println(vertex[0].vertex);
        stack.push(0);
        visited[0]=1;
        //栈不为空
        while(!stack.isEmpty()){
            boolean flag = false;
            //获取栈顶但不弹栈
            int i = stack.peek();
            ArcNode tmp = vertex[i].firstEdge;
            //遍历边表
            while(tmp!=null){
                if (visited[tmp.adjvex]==0){
                    //访问并入栈
                    System.out.println(vertex[tmp.adjvex].vertex);
                    stack.push(tmp.adjvex);
                    //更改访问位,标志位
                    visited[tmp.adjvex]=1;
                    flag = true;
                    break;
                }
                tmp = tmp.next;
            }
            //弹栈
            if(!flag)
                stack.pop();
        }
    }

广度优先遍历

	/**
    * @Description: 图的广搜BFS，邻接矩阵存储，非递归
    * @Param: [vertex, visited]
    * @return: void
    * @Author: zbl
    * @Date: 2019/11/18
    */
    public static void BFS(VertexNode[] vertex,int[] visited){
        for (int i = 0; i<vertex.length; ++i){
            ArcNode tmp = vertex[i].firstEdge;
            //若未访问,则访问并标记
            if (visited[i]==0){
                System.out.println(vertex[i].vertex);
                visited[i]=1;
            }

            while(tmp!=null){
                //若未访问,则访问并标记
                if (visited[tmp.adjvex]==0){
                    System.out.println(vertex[tmp.adjvex].vertex);
                    visited[tmp.adjvex]=1;
                }
                tmp = tmp.next;
            }
        }
    }

完整函数代码

顶点类和边表类在上面已经给出，在此就不重复放出来了。

import javafx.scene.shape.Arc;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
/**
 * author zbl
 *
 * datetime 2019.11.18
 *
 */
public class Main {

    //图的深搜DFS ,非递归
    public static void DFS(int[] vector, int[] visited, int[][] arc){
        //访问第一个顶点并入栈
        System.out.println(vector[0]);
        Stack<Integer> stack = new Stack<Integer>();
        stack.push(0);
        visited[0] = 1;
        while(!stack.isEmpty()){
            //获取栈顶元素
            int x = stack.peek();
            //标志位
            boolean flag = false;
            for (int i = 0; i<vector.length;++i){
                if (visited[i]==0 && arc[x][i]==1){
                    System.out.println(vector[i]);
                    //入栈
                    stack.push(i);
                    //更改访问位,标志位
                    visited[i] = 1;
                    flag = true;
                    break;
                }
            }
            //出栈
            if (!flag)
                stack.pop();
        }
    }

    //图的深搜DFS,递归
    public static void DFS(int[] vector, int[] visited, int[][] arc,int i){
        //访问结点并标记
        System.out.println(vector[i]);
        visited[i]=1;
        for (int j = 0;j<vector.length; ++j){
            if (visited[j]==0 && arc[i][j]==1)
                DFS(vector,visited,arc,j);
        }
    }

    //图的广搜BFS,非递归
    public static void BFS(int[] vector, int[] visited, int[][] arc){
        Queue<Integer> queue = new LinkedList<Integer>();
        //第一个顶点入队
        queue.offer(0);
        while (!queue.isEmpty()){
            //出队
            int x = queue.poll();
            //访问结点并标记
            System.out.println(vector[x]);
            visited[x] = 1;
            //寻找连通的结点并入队
            for (int i = 0; i<vector.length;++i){
                if (visited[i]==0 && arc[x][i]==1){
                    queue.offer(i);
                    visited[i] = 1;
                }

            }
        }
    }

    /**
     * @Description: 图的深搜DFS，邻接矩阵存储，非递归
     * @Param: [vertex, visited]
     * @return: void
     * @Author: zbl
     * @Date: 2019/11/18
     */
    public static void DFS(VertexNode[] vertex,int[] visited){
        Stack<Integer> stack = new Stack<Integer>();
        //访问第一个顶点并入栈
        System.out.println(vertex[0].vertex);
        stack.push(0);
        visited[0]=1;
        //栈不为空
        while(!stack.isEmpty()){
            boolean flag = false;
            //获取栈顶但不弹栈
            int i = stack.peek();
            ArcNode tmp = vertex[i].firstEdge;
            //遍历边表
            while(tmp!=null){
                if (visited[tmp.adjvex]==0){
                    //访问并入栈
                    System.out.println(vertex[tmp.adjvex].vertex);
                    stack.push(tmp.adjvex);
                    //更改访问位,标志位
                    visited[tmp.adjvex]=1;
                    flag = true;
                    break;
                }
                tmp = tmp.next;
            }
            //弹栈
            if(!flag)
                stack.pop();
        }
    }

    /**
    * @Description: 图的深搜DFS，邻接矩阵存储，递归
    * @Param: [vertex, visited, i]
    * @return: void
    * @Author: zbl
    * @Date: 2019/11/18
    */
    public static void DFS(VertexNode[] vertex,int[] visited,int i){
        System.out.println(vertex[i].vertex);
        visited[i]=1;
        ArcNode tmp = vertex[i].firstEdge;
        while(tmp != null){
            int j = tmp.adjvex;
            if(visited[j]==0)
                DFS(vertex,visited,j);
            tmp = tmp.next;
        }
    }
    
    /**
    * @Description: 图的广搜BFS，邻接矩阵存储，非递归
    * @Param: [vertex, visited]
    * @return: void
    * @Author: zbl
    * @Date: 2019/11/18
    */
    public static void BFS(VertexNode[] vertex,int[] visited){
        for (int i = 0; i<vertex.length; ++i){
            ArcNode tmp = vertex[i].firstEdge;
            //若未访问,则访问并标记
            if (visited[i]==0){
                System.out.println(vertex[i].vertex);
                visited[i]=1;
            }

            while(tmp!=null){
                //若未访问,则访问并标记
                if (visited[tmp.adjvex]==0){
                    System.out.println(vertex[tmp.adjvex].vertex);
                    visited[tmp.adjvex]=1;
                }
                tmp = tmp.next;
            }
        }
    }

    public static void main(String[] args) {
        //手动构造点集和边集
        //点集
        int[] vector = {
                0,1,2,3,4,5
        };
        //边集
        int[][] arc ={
                {0,1,1,1,1,0},
                {1,0,0,0,1,0},
                {1,0,0,0,1,0},
                {1,0,0,0,0,0},
                {1,1,1,0,0,1},
                {0,0,0,0,1,1}
        };
        //记录是否访问
        int[] visited = {
                0,0,0,0,0,0
        };
        System.out.println("===============邻接矩阵Start===============");
        System.out.println("Start DFS:");
        DFS(vector,visited,arc);
        System.out.println("End DFS\n");

        for(int i = 0; i<visited.length; ++i)
            visited[i] = 0;

        System.out.println("Start DFS:");
        DFS(vector,visited,arc,0);
        System.out.println("End DFS\n");

        for(int i = 0; i<visited.length; ++i)
            visited[i] = 0;

        System.out.println("Start BFS:");
        BFS(vector,visited,arc);
        System.out.println("End BFS");

        System.out.println("===============邻接矩阵End===============\n");

        System.out.println("===============邻接表Start===============");
        //手动构造点集和边集
        VertexNode[] vertex = new VertexNode[5];
        for (int i = 0;i<vertex.length;++i){
            vertex[i] = new VertexNode();
            vertex[i].vertex=i;
        }


        ArcNode V03 = new ArcNode(3,null);
        ArcNode V02 = new ArcNode(2,V03);
        ArcNode V01 = new ArcNode(1,V02);
        ArcNode V12 = new ArcNode(4,null);
        ArcNode V11 = new ArcNode(0,V12);
        ArcNode V22 = new ArcNode(3,null);
        ArcNode V21 = new ArcNode(0,V22);
        ArcNode V32 = new ArcNode(2,null);
        ArcNode V31 = new ArcNode(0,V32);
        ArcNode V41 = new ArcNode(1,null);

        vertex[0].firstEdge=V01;
        vertex[1].firstEdge=V11;
        vertex[2].firstEdge=V21;
        vertex[3].firstEdge=V31;
        vertex[4].firstEdge=V41;

        for(int i = 0; i<visited.length; ++i)
            visited[i] = 0;

        System.out.println("Start DFS:");
        DFS(vertex,visited);
        System.out.println("End DFS\n");

        for(int i = 0; i<visited.length; ++i)
            visited[i] = 0;

        System.out.println("Start DFS:");
        DFS(vertex,visited,0);
        System.out.println("End DFS\n");

        for(int i = 0; i<visited.length; ++i)
            visited[i] = 0;

        System.out.println("Start BFS:");
        BFS(vertex,visited);
        System.out.println("End BFS");
        System.out.println("===============邻接表End===============");
    }
}

注意事项

以上代码只适用于强连通图！！！
以上代码只适用于强连通图！！！
以上代码只适用于强连通图！！！
重要的事说三遍。

参考文献

  • 王红梅，胡明，王涛编著. 数据结构（C++版）（第二版）[M]. 清华大学出版社.
白亮吖雅黑丫
关注
  • 2
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
算法导论 22.2-8 无向图遍历
幸福在路上
12-23 4346
一、题目 设G=(V,E)是一个连通的无向图。请给出一个O(V+E)时间的算法，以计算图G中的一条路径，对于E中的每一条 边，该路径恰好在每一个方向上遍历一次。如果你身处一个迷宫之中，说明如何才能找到出路。 二、思考 直觉就是说DFS，这一节讲的是BFS，不知道怎么用BFS处理 三、代码 1.Link_Graph.h #include #include using
C++实现邻接表无向图及其两种遍历
qq_46027243的博客
02-26 792
#include<iostream> #include<string.h> #include<queue> #define MaxSize 100 //最大结点数 using namespace std; typedef struct ArcNode //存储与结点相连的边 { int adjvex; //该边所指向的顶点的位置 ArcNode* nextarc; //指向下一条与结点相连的边 int weight; //边的权重 }ArcNode;
无向图 遍历
weixin_43294560的博客
07-19 1500
【代码】无向图 遍历。
无向图的深度优先遍历
热门推荐
Gerald的博客
10-17 4万+
描述     简单介绍一下图，图就是由一些小圆点（称为顶点）和连接这些小圆点的直线（称为边）组成的。例如下图的由五个顶点（编号1、2、3、4、5）和五条边（1-2、1-3、1-5、2-4、3-5）组成     现在从1号顶点开始遍历这个图，遍历是指把图的每一个顶点都访问一次。使用深度有限搜索来遍历这个图将会得到如下结果。     这五个顶点的访问顺序如下图     使用深度优先...
无向图的遍历----笔试题
身在边城 心在编程
11-01 764
无向图的遍历1、不邻接植花2、概率最大的路径 1、不邻接植花 题目：有 N 个公园，公园之间是互通的，它们的关系由 paths 数组给出，要求是，为每个公园种植一朵花，使得通过路径相连的任何两个公园的花的种类不同，种类为(1~N) 思路 一、求邻接表; 二、遍历顶点 1、可用颜色列表 set color = {1, 2, 3, 4}; 2、遍历当前顶点的所有相邻节点，从可用颜色中移除相邻节点的颜色 3、从可用的颜色中选择一个标记当前节点; vector<int> gardenNoAdj
c语言 无向图的深度优先遍历算法实现
11-30
通过键盘输入图的顶点，以及每一条边的两个顶点，从而建立无向图。实现无向图的深度优先遍历算法。要求以用户给定的结点为起始点，显示深度优先遍历次序。
算法和数据结构学习笔记.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
数据结构算法学习笔记.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
数据结构（C语言描述）学习笔记.zip
06-17
有向图和无向图是图的基本类型，图遍历包括深度优先搜索（DFS）和广度优先搜索（BFS）。 四、排序与查找算法 1. 冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序：这些是常见的排序算法，各有优缺点，...
数据结构与算法学习笔记.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
图的遍历（有向图和无向图）
12-09
无向图和有向图的深度优先和宽度优先遍历（包括递归和非递归两种方式）。
无向图的遍历演示（两种遍历方式）
09-17
以邻接多重表为存储结构，实现连通无向图的深度优先和广度优先遍历。以用户指定的结点为起点，以用户的意愿为主选择遍历的方式，以用户的意愿为主看是否要推出程序。
数据结构与算法的学习笔记.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
数据结构无向图遍历-完整代码
孤桜懶契
06-13 835
[VC]数据结构图遍历完整代码-无向（邻接矩阵和邻接表） 执行结果 完整代码奉上 #include <iostream> #include <stdio.h> #include <stdlib.h> using namespace std; #define MaxVertexNum 100 //定义最大顶点数 //=========定义标志向量，为全局变量======= typedef enum {FALSE,TRUE} Boolean; Boolean vis
邻接表无向图的广度优先遍历C/C++代码实现
Ycy的博客
06-14 3094
广度优先遍历： 与深度优先遍历不同，广度优先遍历还需要一个辅助队列，用来按顺序存储遍历过的顶点以便出队的顶点总是先被遍历的顶点。 以该图为例： 代码如下： #include<stdio.h> #define MVNum 100 typedef char OtherInfo; typedef char VerTexType; //邻接表存储结构 typedef struct ArcNode //边结点 { int adjvex; struct ArcNode *nextarc;
无向图的DFS/BFS遍历
代码行
04-30 1703
#include&lt;bits/stdc++.h&gt; using namespace std; int vis[25],flag=1; queue&lt;int&gt;s; typedef struct node //边结点 { int a; //该边所指向的顶点的位置 struct node *next; //指向下一条边的...
无向图的遍历 java_java编程无向图结构的存储及DFS操作代码详解
weixin_42352080的博客
02-13 235
图的概念图是算法中是树的拓展，树是从上向下的数据结构，结点都有一个父结点(根结点除外)，从上向下排列。而图没有了父子结点的概念，图中的结点都是平等关系，结果更加复杂。无向图 有向图图G=(V,E)，其中V代表顶点Vertex，E代表边edge，一条边就是一个定点对(u,v)，其中(u,v)∈...
数据结构 Java DS——链表部分经典题目 (1)
最新发布
cjejwe的博客
07-09 320
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
数据结构学习笔记.docx
12-02
《数据结构学习笔记.docx》是一份包含关于算法时间复杂度、空间复杂度以及线性表的基本特点和存储结构的学习笔记。在学习笔记中提到，算法的时间复杂度T(n)表示算法执行时间的增长率和问题规模n的增长率相同，用O(f...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值