图的概念和数据储存，以及图的遍历（图的深度优先遍历和图的广度优先搜索）

倾城璧

已于 2024-05-22 12:01:56 修改

阅读量1.4k

点赞数 42

分类专栏： JAVA数据结构基础文章标签：深度优先图搜索广度优先

于 2024-05-20 13:35:18 首次发布

本文链接：https://blog.csdn.net/2302_79993788/article/details/138926210

版权

JAVA数据结构基础专栏收录该内容

9 篇文章 0 订阅

订阅专栏

为什么要引入图这个概念？先让我们了解一下图的应用场景

计算机视觉：在图像和视频分析中，图可以用来表示图像中的对象和它们之间的关系。通过图的算法，可以进行对象识别、场景理解等。
软件工程：在软件系统中，图可以用来表示类之间的关系、模块之间的依赖等。通过图的算法，可以进行代码重构、依赖分析等。
电力系统：在电力网络中，图可以用来表示电网中的节点（发电站、变电站等）和边（输电线）。通过图的算法，可以进行电网优化、故障检测等。
物流和供应链管理：在物流和供应链管理中，图可以用来表示仓库、配送中心、运输路线等。通过图的算法，可以进行路径规划、库存优化等。
经济学和金融学：在经济学和金融学中，图可以用来表示市场中的交易网络、投资关系等。通过图的算法，可以进行市场分析、风险评估等。

图的应用场景非常广泛，几乎所有涉及复杂关系和网络结构的问题都可以用图来建模和解决。

图的概念和抽象数据类型

1.图的定义和术语

图是由顶点集合和边集合组成的数据结构，图中的数据元素通常称为顶点，顶点之间的关系称为边。一个图G=（V,E），V是顶点vi的集合（0≤i<n），n为顶点数，E是边的集合。

（1）无向图

无向图中的边是没有方向的，通常是用来表示节点间的关系。

下面是无向图G1

无向图G1的顶点集合V和集合E

顶点的集合：V(G1)={A,B,C,D,E,F,G}；

边的集合：E(G1)={（A,B),（A,C）（A,D）,（B,C）,（B,E）,（C,E）,（C,D）,（D,E）,（D,F）}

树是连通的无回路和无向图。假设有一颗树T有n个顶点，则其必有n-1条边。

（2）有向图

有向图或有向图是其中边缘具有特定方向的图数据结构。它们源自一个顶点，最终达到另一个顶点。

下面是有向图G2

顶点集合：V(G,)={A,B,C,D,E}；

边的集合：E(G,)={ <A,B >,< A, D >,< A,E >,< B,C >,< B,D >,< C,E >,<D,C >,<D,E >}；

（3）带权图

带权图是指边具有的权值，在不同应用中，权值有着不同的含义，通常表示边上的一种成本，距离，时间或其他量度，带权图可以是无向的也可以是有向的。

（4）邻接节点

若（vi,vj）是无向图中的一条边，就是说两个节点间存在一条边，则称vi和vj互为邻接节点，就是说两个节点间存在一条边。

（5）顶点的度

顶点的度是指定点vi相关联的边数，记为degree（vi）。度为0的顶点称为孤立点，度为1的顶点称为悬挂点。

B的度为4，E的度为1（悬挂点），x的度为0（孤立点）。

在有向图中，以vi为终边的边数称为vi的入度，以vi为起点的边数称为vi的出度。比如上面讲到的有向图中的B的入度=1，出度=2。

（6）路径

路径是指一个顶点到另外一个顶点的路线，简单路径是指路径上的各顶点都不重复。

回路是指起点和终点相同且长度大于1的简单路径，回路又称为环，如（A，B，D，C）是一条简单路径，（A，B，C，D）是一条回路。

对于不带权图，路径长度是指路径上的边数。对于带权图，路径长度是指路径上各条边的权值之和。例如下面的（A，B，D，C）路径长度为3。

邻接矩阵

（1）邻接矩阵概念及其表示

图的表示方法有两种：二维数组表示（邻接矩阵）；链表表示（邻接表）。

如果图的边没有权值，用0表示顶点之间无边，用1表示顶点之间有边。
如果图的弧有权值，用无穷大表示顶点之间无边，用权值表示顶点之间有边，同一点之间的权值为0。

通过观察可知，无向图的邻接矩阵是对称点，有向图的邻接矩阵不一定对称

使用邻接矩阵实现图的缺点：
使用邻接矩阵这种弄存储方式的空间复杂度是N^2，所以当处理的问题规模比较大的话，内存空间极有可能不够用，可以发现，当很多边不存在的时候，内存空间同样需要存储数据，这样会造成空间的一定损失。

（2）邻接表

针对上面邻接矩阵比较浪费内存空间的问题，诞生了图的另外一种存储方法—邻接表 。

邻接表只关心存在的边，不关心不存在的边。

邻接链表使用一个链表来存储某个顶点的所有后继相邻顶点。对于图中每个顶点 Vi，把所有邻接于 Vi 的顶点 Vj 链成一个单链表，这个单链表称为顶点 Vi 的 邻接表。如下图所示：

在无向图中，邻接表元素个数等于边的条数的两倍，如左图所示的无向图中，边的条数为 7，邻接表存储的元素个数为 14。
在有向图中，邻接表元素个数等于边的条数，如右图所示的有向图中，边的条数为 8，邻接表存储的元素个数为 8。

图的遍历

图的深度优先搜索策略

图的遍历是指从图中的某个顶点vi出发，沿着途中的边前行，到达并访问途中所有的顶点，且每个顶点仅被访问一次。

遍历图比较复杂，我们需要考虑下面三个问题并提供解决办法

指定遍历的起始访问顶点，可从图G中任意一个顶点vi出发
由于一个顶点与多个顶点相邻，因此要在多个邻接顶点之间约定一种访问次序。通常按照定点的存储顺序进行遍历。
由于图中存在回路，在访问某个顶点后，可能沿着某条路径又回到该顶点。因此，为了避免重复访问同一个顶点，在遍历过程中必须对访问过的顶点进行标记。通常，设置一个标记数组来记录每个顶点是否被访问过。

深度优先搜索（Depth First Search ,DFS）策略遍历图G一个连通分量的规则如下，从其中一个顶点vi出发，访问顶点vi；寻找下一个未被访问的邻接顶点vj，再从vj遍历图G；继续，直到访问了图G从顶点vi出发的一个连通分量。

（1）无向图的深度优先搜索

深度优先搜索跟递归类似，你们先可以去了解一下递归再来看深度优先搜索会更加好理解。

最初是从A点开始遍历，从B-C-D-F这样的顺序遍历，每一个访问顶点入栈，记录递归调用的执行路径。

当栈的顶点E没有被下一个未被访问的邻接顶点时，E出栈，递归返回之前的顶点D，再去寻找顶点D的邻接节点F（未被访问）。

此时，从顶点A出发的一次深度优先搜索（A，B，C，D，E，F），遍历了G1的一个连通分量，由两条路径（A，B，C，D，E）和（D，F）组成了该连通分量的一颗深度优先生成树。以深度优先搜索遍历得到的生成树，称为深度优先生成树。

（2）有向图的深度优先搜索

从顶点A出发一次深度优先搜索（A，B，C，E，D），由两条路径<A,B,C,E>和<B,D>组成，访问了G2的所有顶点，所以有向图G2是连通图。

从顶点C出发，深度优先搜索了3次（C，E），（D）,(A,B)才完成遍历，所以有向图是非强连通图。

图的广度优先遍历

（1）无向图的广度优先搜索

广度优先遍历（Breadth First Search, BFS）策略遍历图G的规则，就是树的层次遍历算法。

无向图G1从顶点A出发的一次广度优先搜索遍历过程：从A出发，再次访问邻接节点（B，C，D）（未被访问）；之后，访问B的邻接顶点E，再访问D的邻接节点F，使用队列存储方式访问顶点和其他邻接节点。

队列的作用是存储当前访问顶点所有邻接顶点，这些顶点排队等待被访问，当访问完当前顶点时，出队一个顶点，即下一个要访问的顶点。

（2）有向图的广度优先搜索

先访问D，再访问D的邻接节点C，E，遍历连通分量（D，C，E）；然后从A出发，遍历连通分量（A，B）。

图的深度和广度优先搜索算法

import sun.security.provider.certpath.AdjacencyList;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;

public class AdjacencyMatrix {
    private ArrayList<String> vexs;//顶点表
    private int[][] edges;//边表
    int numVertexes;//顶点的数量
    int numEdges;//边的数量
    boolean[] visited;


    public AdjacencyMatrix(int numVertexes, int numEdges) {
        this.vexs = new ArrayList<String>(numVertexes);//用于存储图中的顶点数量
        this.edges = new int[numVertexes][numVertexes];//用于存储图中边的数量
        this.numVertexes = numVertexes;
        this.numEdges = numEdges;
        this.visited = new boolean[numVertexes];
    }
    private void insertVex(String v){
        vexs.add(v);//将新的顶点v添加到vexs列表中
    }
    private void insertEdge(int v1,int v2,int weight){
        edges[v1][v2]=weight;
        edges[v2][v1]=weight;
    }
    private void show(){
        for(int[] link:edges){
            System.out.println(Arrays.toString(link));
        }
    }

    private void DFS(int i){
        visited[i]=true;
        System.out.print(vexs.get(i)+" ");
        for (int j = 0; j < numVertexes; j++) {
            if (edges[i][j]>0&&!visited[j]) {
                DFS(j);
            }
        }
    }
    private void DFSTraverse(){
        int i;
        for (i = 0; i < numVertexes; i++) {
            visited[i]=false;
        }
        for ( i = 0; i <numVertexes ; i++) {
            if(!visited[i]){
                DFS(i);
            }

        }
    }
    private void BFSTraverse(){
        int i ,j ;
        LinkedList queue =new LinkedList();
        for (i = 0; i < numVertexes; i++) {
            visited[i] =false;
        }
        for(i =0;i<numVertexes;i++){
            if(!visited[i]){
                visited[i]=true;
                System.out.print(vexs.get(i)+" ");
                queue.addLast(i);
                while (!queue.isEmpty()){
                    i=(Integer)queue.removeFirst();
                    for(j =0;j<numVertexes;j++){
                        if(edges[i][j]>0&&!visited[j]){
                            visited[j]=true;
                            System.out.print(vexs.get(j)+" ");
                            queue.addLast(j);
                        }
                    }
                }
            }
        }


    }
    public static void main(String[] args) {
        int numVertexes = 9;
        int numEdges = 15;
        AdjacencyMatrix graph = new AdjacencyMatrix(numVertexes, numEdges);
        graph.insertVex("A");
        graph.insertVex("B");
        graph.insertVex("C");
        graph.insertVex("D");
        graph.insertVex("E");
        graph.insertVex("F");
        graph.insertVex("G");
        graph.insertVex("H");
        graph.insertVex("I");
        graph.insertEdge(0, 1, 1);
        graph.insertEdge(0, 5, 1);
        graph.insertEdge(1, 2, 1);
        graph.insertEdge(1, 6, 1);
        graph.insertEdge(1, 8, 1);
        graph.insertEdge(2, 3, 1);
        graph.insertEdge(2, 8, 1);
        graph.insertEdge(3, 4, 1);
        graph.insertEdge(3, 6, 1);
        graph.insertEdge(3, 7, 1);
        graph.insertEdge(3, 8, 1);
        graph.insertEdge(4, 7, 1);
        graph.insertEdge(4, 5, 1);
        graph.insertEdge(5, 6, 1);
        graph.insertEdge(6, 7, 1);
        System.out.println("邻接矩阵");
        graph.show();
        System.out.print("深度优先遍历：");
        graph.DFSTraverse();
        System.out.println();
        System.out.print("广度优先遍历：");
        graph.BFSTraverse();
    }



}