图的表示及遍历

最新推荐文章于 2021-08-24 19:16:36 发布
最新推荐文章于 2021-08-24 19:16:36 发布
阅读量466 收藏 1
点赞数
分类专栏： 数据结构 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ecjtuhq/article/details/106270091
版权

一、图的表示

1.邻接矩阵

缺点是比较浪费空间，但是优点是查询效率高，而且方便矩阵运算。

a.有向图

  • 顶点vi的度是邻接矩阵中的第i行元素之和。
  • 对称矩阵，可压缩存储，有n个结点的无向图需要的存储空间为n(n+1)/2。

b.无向图

  • 矩阵不一定对称，有n个顶点的有向图需要存储空间为n^2。
  • 顶点vi的出度是邻接矩阵中第i行元素之和，顶点vi的出度是邻接矩阵中第i列元素之和。

2.邻接表

比较节省存储空间，但链表不方便查找，所以查询效率没有邻接矩阵存储方式高。

  • 图中顶点用一个一维数组存储。顶点数组中，每个数据元素还需要存储指向第一个邻接点的指针，以便于查找该结点的边信息。
  • 图中每个顶点vi的所有邻接点构成一个线性表。由于邻接点的个数不定，所以用单链表存储。无向图中称为顶点vi的边表，有向图则称为顶点vi作为弧尾的出边表。

a.有向图

b.无向图

二、图的遍历

1.广度优先搜索(BFS)

借助队列来实现，遍历得到的路径是起始顶点到终止顶点的最短路径。

a.基于邻接矩阵的实现

public class Graph_AdjacencyMatrix_Bfs {

    private int mVertexNum; // 顶点数
    private int[][] mAdjacencyMatrix; // 邻接矩阵

    public Graph_AdjacencyMatrix_Bfs(int vertexNum) {
        this.mVertexNum = vertexNum;
        this.mAdjacencyMatrix = new int[vertexNum][vertexNum];
        for (int i = 0; i < vertexNum; ++i) {
            for (int j = 0; j < vertexNum; ++j) {
                mAdjacencyMatrix[i][j] = 0;
            }
        }
    }

    /**
     * 添加图的边
     *
     * @param s 起始顶点
     * @param t 终止顶点
     */
    public void addEdge(int s, int t) {
        mAdjacencyMatrix[s][t] = 1;
        mAdjacencyMatrix[t][s] = 1; // 无向图一条边存两次
    }

    /**
     * 广度优先搜索(最短路径)
     *
     * @param s
     * @param t
     */
    public void bfs(int s, int t) {
        if (s >= mVertexNum || t >= mVertexNum || s == t) {
            return;
        }

        // visited是用来记录已经被访问的顶点，用来避免顶点被重复访问
        boolean[] visited = new boolean[mVertexNum];
        visited[s] = true;

        // prev用来记录搜索路径，prev[i]存储的是：顶点i是从哪个前驱顶点遍历过来的
        int[] prev = new int[mVertexNum];
        for (int i = 0; i < mVertexNum; ++i) {
            prev[i] = -1;
        }

        // queue是一个队列，用来存储已经被访问，但相连的顶点还没有被访问的顶点
        Queue<Integer> queue = new LinkedList<>();
        queue.add(s);

        while (queue.size() != 0) {
            int w = queue.poll();
            for (int i = 0; i < mVertexNum; ++i) {
                int v = mAdjacencyMatrix[w][i];
                if (v == 1 && !visited[i]) {
                    prev[i] = w;
                    if (i == t) {
                        print(prev, s, t);
                        return;
                    }
                    visited[i] = true;
                    queue.add(i);
                }
            }
        }
    }

    /**
     * 递归打印 s->t 的路径
     *
     * @param prev
     * @param s
     * @param t
     */
    private void print(int[] prev, int s, int t) {
        if (prev[t] != -1 && t != s) {
            print(prev, s, prev[t]);
        }
        System.out.print(t + " ");
    }

    public static void main(String[] args) {
        Graph_AdjacencyMatrix_Bfs graph = new Graph_AdjacencyMatrix_Bfs(8);
        graph.addEdge(0, 1);
        graph.addEdge(0, 3);
        graph.addEdge(1, 2);
        graph.addEdge(1, 4);
        graph.addEdge(2, 5);
        graph.addEdge(4, 5);
        graph.addEdge(4, 6);
        graph.addEdge(5, 7);
        graph.addEdge(6, 7);
        graph.bfs(0, 6);
    }
}

b.基于邻接表的实现

public class Graph_AdjacencyList_Bfs {

    private int mVertexNum; // 顶点数
    private List<Integer> mAdjacencyList[]; // 邻接表

    public Graph_AdjacencyList_Bfs(int vertexNum) {
        this.mVertexNum = vertexNum;
        this.mAdjacencyList = new LinkedList[vertexNum];
        for (int i = 0; i < vertexNum; ++i) {
            mAdjacencyList[i] = new LinkedList<>();
        }
    }

    /**
     * 添加图的边
     *
     * @param s 起始顶点
     * @param t 终止顶点
     */
    public void addEdge(int s, int t) {
        mAdjacencyList[s].add(t);
        mAdjacencyList[t].add(s); // 无向图一条边存两次
    }

    /**
     * 广度优先搜索(最短路径)
     *
     * @param s
     * @param t
     */
    public void bfs(int s, int t) {
        if (s >= mVertexNum || t >= mVertexNum || s == t) {
            return;
        }

        // visited是用来记录已经被访问的顶点，用来避免顶点被重复访问
        boolean[] visited = new boolean[mVertexNum];
        visited[s] = true;

        // prev用来记录搜索路径，prev[i]存储的是：顶点i是从哪个前驱顶点遍历过来的
        int[] prev = new int[mVertexNum];
        for (int i = 0; i < mVertexNum; ++i) {
            prev[i] = -1;
        }

        // queue是一个队列，用来存储已经被访问，但相连的顶点还没有被访问的顶点
        Queue<Integer> queue = new LinkedList<>();
        queue.add(s);

        while (queue.size() != 0) {
            int w = queue.poll();
            for (int i = 0; i < mAdjacencyList[w].size(); ++i) {
                int q = mAdjacencyList[w].get(i);
                if (!visited[q]) {
                    prev[q] = w;
                    if (q == t) {
                        print(prev, s, t);
                        return;
                    }
                    visited[q] = true;
                    queue.add(q);
                }
            }
        }
    }

    /**
     * 递归打印 s->t 的路径
     *
     * @param prev
     * @param s
     * @param t
     */
    private void print(int[] prev, int s, int t) {
        if (prev[t] != -1 && t != s) {
            print(prev, s, prev[t]);
        }
        System.out.print(t + " ");
    }

    public static void main(String[] args) {
        Graph_AdjacencyList_Bfs graph = new Graph_AdjacencyList_Bfs(8);
        graph.addEdge(0, 1);
        graph.addEdge(0, 3);
        graph.addEdge(1, 2);
        graph.addEdge(1, 4);
        graph.addEdge(2, 5);
        graph.addEdge(4, 5);
        graph.addEdge(4, 6);
        graph.addEdge(5, 7);
        graph.addEdge(6, 7);
        graph.bfs(0, 6);
    }
}

2.深度优先搜索(DFS)

常用递归实现，即借助栈来实现，遍历得到的路径不一定是起始顶点到终止顶点的最短路径。

a.基于邻接矩阵的实现

public class Graph_AdjacencyMatrix_Dfs {

    private boolean isFound; // 是否找到终止顶点

    private int mVertexNum; // 顶点数
    private int[][] mAdjacencyMatrix; // 邻接表

    public Graph_AdjacencyMatrix_Dfs(int vertexNum) {
        this.mVertexNum = vertexNum;
        this.mAdjacencyMatrix = new int[vertexNum][vertexNum];
        for (int i = 0; i < vertexNum; ++i) {
            for (int j = 0; j < vertexNum; ++j) {
                mAdjacencyMatrix[i][j] = 0;
            }
        }
    }

    /**
     * 添加图的边
     *
     * @param s 起始顶点
     * @param t 终止顶点
     */
    public void addEdge(int s, int t) {
        mAdjacencyMatrix[s][t] = 1;
        mAdjacencyMatrix[t][s] = 1; // 无向图一条边存两次
    }

    /**
     * 深度优先搜索
     *
     * @param s
     * @param t
     */
    public void dfs(int s, int t) {
        if (s >= mVertexNum || t >= mVertexNum || s == t) {
            return;
        }

        // visited是用来记录已经被访问的顶点，用来避免顶点被重复访问
        boolean[] visited = new boolean[mVertexNum];

        // prev用来记录搜索路径，prev[i]存储的是：顶点i是从哪个前驱顶点遍历过来的
        int[] prev = new int[mVertexNum];
        for (int i = 0; i < mVertexNum; ++i) {
            prev[i] = -1;
        }

        recurDfs(s, t, visited, prev);
        print(prev, s, t);
    }

    /**
     * 递归方法
     *
     * @param w
     * @param t
     * @param visited
     * @param prev
     */
    private void recurDfs(int w, int t, boolean[] visited, int[] prev) {
        if (isFound) {
            return;
        }

        visited[w] = true;
        if (w == t) {
            isFound = true;
            return;
        }

        for (int i = 0; i < mVertexNum; ++i) {
            int v = mAdjacencyMatrix[w][i];
            if (v == 1 && !visited[i]) {
                prev[i] = w;
                recurDfs(i, t, visited, prev);
            }
        }
    }

    /**
     * 递归打印 s->t 的路径
     *
     * @param prev
     * @param s
     * @param t
     */
    private void print(int[] prev, int s, int t) {
        if (prev[t] != -1 && t != s) {
            print(prev, s, prev[t]);
        }
        System.out.print(t + " ");
    }

    public static void main(String[] args) {
        Graph_AdjacencyMatrix_Dfs graph = new Graph_AdjacencyMatrix_Dfs(8);
        graph.addEdge(0, 1);
        graph.addEdge(0, 3);
        graph.addEdge(1, 2);
        graph.addEdge(1, 4);
        graph.addEdge(2, 5);
        graph.addEdge(4, 5);
        graph.addEdge(4, 6);
        graph.addEdge(5, 7);
        graph.addEdge(6, 7);
        graph.dfs(0, 6);
    }
}

b.基于邻接表的实现

public class Graph_AdjacencyList_Dfs {

    private boolean isFound; // 是否找到终止顶点

    private int mVertexNum; // 顶点数
    private List<Integer> mAdjacencyList[]; // 邻接表

    public Graph_AdjacencyList_Dfs(int vertexNum) {
        this.mVertexNum = vertexNum;
        this.mAdjacencyList = new LinkedList[vertexNum];
        for (int i = 0; i < vertexNum; ++i) {
            mAdjacencyList[i] = new LinkedList<>();
        }
    }

    /**
     * 添加图的边
     *
     * @param s 起始顶点
     * @param t 终止顶点
     */
    public void addEdge(int s, int t) {
        mAdjacencyList[s].add(t);
        mAdjacencyList[t].add(s); // 无向图一条边存两次
    }

    /**
     * 深度优先搜索
     *
     * @param s
     * @param t
     */
    public void dfs(int s, int t) {
        if (s >= mVertexNum || t >= mVertexNum || s == t) {
            return;
        }

        // visited是用来记录已经被访问的顶点，用来避免顶点被重复访问
        boolean[] visited = new boolean[mVertexNum];

        // prev用来记录搜索路径，prev[i]存储的是：顶点i是从哪个前驱顶点遍历过来的
        int[] prev = new int[mVertexNum];
        for (int i = 0; i < mVertexNum; ++i) {
            prev[i] = -1;
        }

        recurDfs(s, t, visited, prev);
        print(prev, s, t);
    }

    /**
     * 递归方法
     *
     * @param w
     * @param t
     * @param visited
     * @param prev
     */
    private void recurDfs(int w, int t, boolean[] visited, int[] prev) {
        if (isFound) {
            return;
        }

        visited[w] = true;
        if (w == t) {
            isFound = true;
            return;
        }

        for (int i = 0; i < mAdjacencyList[w].size(); ++i) {
            int q = mAdjacencyList[w].get(i);
            if (!visited[q]) {
                prev[q] = w;
                recurDfs(q, t, visited, prev);
            }
        }
    }

    /**
     * 递归打印 s->t 的路径
     *
     * @param prev
     * @param s
     * @param t
     */
    private void print(int[] prev, int s, int t) {
        if (prev[t] != -1 && t != s) {
            print(prev, s, prev[t]);
        }
        System.out.print(t + " ");
    }

    public static void main(String[] args) {
        Graph_AdjacencyList_Dfs graph = new Graph_AdjacencyList_Dfs(8);
        graph.addEdge(0, 1);
        graph.addEdge(0, 3);
        graph.addEdge(1, 2);
        graph.addEdge(1, 4);
        graph.addEdge(2, 5);
        graph.addEdge(4, 5);
        graph.addEdge(4, 6);
        graph.addEdge(5, 7);
        graph.addEdge(6, 7);
        graph.dfs(0, 6);
    }
}

 

一杯苦芥
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode102.二叉树的层序遍历、华为OD机试(C卷,200分)- 二叉树的广度优先遍历
欢迎来到我的博客~
07-21 378
现有两组字母，分别表示后序遍历（左孩子->右孩子->父节点）和中序遍历（左孩子->父节点->右孩子）的结果，请你输出层序遍历的结果。每个输入文件一行，第一个字符串表示后序遍历结果，第二个字符串表示中序遍历结果。（每串只包含大写字母）有一棵二叉树，每个节点由一个大写字母标识(最多26个节点）。1、从中序遍历与后序遍历构造二叉树（leetcode106）2、二叉树的层序遍历（leetcode102）输出仅一行，表示层序遍历的结果，结尾换行。输入 CBEFDA CBAEDF。
图的表示和遍历
david_liang
10-13 1198
图的表示图(Graph)是由顶点(Vertex)和边(Edge)构成的一种集合,及 G=(V,E)G = (V, E),图在数据结构中有两种表示方式：邻接矩阵和邻接链表邻接矩阵对于图G=(V,E)G = (V, E)的邻接矩阵的表示方式，通常是将图G的节点编为0,1,2,3,...,|V−1|0, 1, 2, 3, ..., |V-1|,这种编号是任意的也可以从1开始进行编号，那么G的邻接矩阵表示由
图 Graph-图的表示及其遍历
aitie1479的博客
03-06 172
2018-03-05 16:19:46 图是计算机科学中的一个非常重要的概念，图是一种多对多的关系。从某种角度上来说树和链表都是图的一种特例。 一、图的抽象数据类型 二、表示图的方法 图是由结点和边构成的，只要能通过某种方式将结点和边的信息表示出来就可以了。以下是两种最常见的图的表示方法，值得一提的是，并不是只有这两种方法来表示图。 邻接矩阵 邻接矩阵G...
图系列之_图的表示和遍历
selfsongs
08-17 482
图系列之_图的表示图两种表示方法图的遍历（DFS和BFS)代码实现无向图有向图 参考： 数据结构——图的概述 图是由顶点V集和边E集构成，因此图可以表示成G=(V,E)G=(V,E)G=(V,E)。 图两种表示方法 1.邻接矩阵法； 无向图 邻接矩阵的特点为：主对角线一定为0且为对称矩阵 有向图 邻接矩阵是最容易理解的表示方法，优点是简单易懂，缺点是可能会占用很多存储空间，且没有任何意义，空间复杂度有向图是O(n2)O(n^2)O(n2) 如果图的边不是很多，则不太适合用邻接矩阵表示。一般邻接矩阵适合表
图的表示 与 图的遍历（DFS 和 BFS）
Appleeatingboy的博客
08-24 588
链表、树与图的关系： 链表是特殊化的树，树是特殊化的图。 一、图的存储 图的存储有三种方式：邻接矩阵、出边数组和邻接表。 上图中三种表示方式的介绍如下： 1.邻接矩阵： 矩阵中的值为1, 代表 存在行坐标到列坐标 的边。 如果有权重值的话，可以将1设置成相应的权重值。 这种表示方法的缺点是边数相对顶点较少的图，存在对存储空间的浪费。 2.出边数组： 数组[1,2...
图的表示方法和遍历
qq_44910084的博客
02-06 210
图的储存 下述内容参考于算法笔记 邻接矩阵 使用一个二维数组来表示顶点之间的关系，二维数组大小就是边的权重。 使用邻接矩阵会使用过多的空间，适用于顶点数不太大的情况。 邻接表 使用链表结构。直观的连接。 使用变长数组 vector<int> Adj[N] Adj[i]表示一个变长数组，储存相邻顶点的信息。 如果还需要储存权重值 typedef struct Node{ int ...
C#遍历文件夹及子目录下所有图片
08-31
在C#编程中，遍历文件夹及其子目录下的所有图片是一项常见的任务，尤其是在处理大量图像数据时。本文将详细讲解如何使用C#实现这一功能，并结合JavaScript展示这些图片。 首先，我们需要用到C#的`System.IO`命名...
头歌数据结构图的邻接表存储及遍历操作
05-26
根据给定文件的信息，我们可以总结出以下关于图的邻接表存储及遍历操作的关键知识点： ### 一、邻接表的基本概念 邻接表是一种用于表示图的存储结构，适用于稀疏图（即边的数量远小于顶点数量的平方）。它通过一...
头歌数据结构图的邻接矩阵存储及遍历操作
05-26
### 头歌数据结构图的邻接矩阵存储及遍历操作 #### 一、邻接矩阵存储 在数据结构中，图是一种常见的非线性结构，用于表示对象间的关系。根据边是否有方向，图可以分为有向图和无向图。而根据边是否具有权重值，又...
树和图在关系型数据库中的表示及遍历.doc
06-08
树和图在关系型数据库中的表示及遍历
图的存储和遍历
04-19
用数组表示法存储图，并实现图的深度优先遍历和广度优先遍历。
Graphs:简单的图表示和遍历
07-13
在本主题中，我们将深入探讨"简单的图表示和遍历"，特别是与Java编程语言相关的实现。图由顶点（或节点）和边（连接顶点的关系）组成，可以用来模拟各种现实世界中的关系，如社交网络、交通网络等。 首先，我们来...
图之表示和遍历
qustqustjay的专栏
07-03 1074
学习笔记！！！！！ 一、什么是图（Graphy）？ 表示“多对多”的关系，包含一组顶点（V表示顶点集合）和一组边（E表示边的集合）。 边是顶点对：(v,w)属于E，其中v,w属于V 有向边表示从v指向w的边,不考虑重边和自回路。 图的数据对象集：G(V,E)由一个非空的有限顶点集合v和一个有限边集合E组成。注意，图可以没有边，但至少会有一个顶点。 使用邻接矩阵表示图：
图的表示与遍历（c）
sadfdv的博客
07-26 344
图的表示与遍历 邻接矩阵，邻接表以及深度优先搜索，广度优先搜索 1.邻接矩阵 typedef struct Graph* graph; //邻接矩阵结构表示 struct Graph { //datatype data[maxsize];//当顶点具有其他意义时 int dot;//顶点数 int line;//边数 int map[maxsize][maxsize]; }; //所插入的边结构表示 typedef struct linenode* edge; struct linenode {
图的邻接矩阵表示法及广度优先遍历
白话机器学习
06-18 1198
// 广度优先遍历.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include #include using namespace std; #define MAXVEX 10 #define INFINITY 65535 typedef struct { char ve
图1---------------图的表示和遍历算法
lurengu00的专栏
09-18 791
图的表示方法： 邻接矩阵法（太浪费空间，但确实把所有信息都表示了出来，计算度或者各种操作的话很方便，当然用无向图的对称性、只存放非0结点可以优化） 邻接表（算比较好的一种方法，但是对于有向图计算入度必须遍历，用逆邻接表、十字链表优化） 十字链表（和邻接表太类似） 遍历算法： 图是标准的多对多结构，因此不构成环并且不重复访问vertex需要一个标志数组visited，循环这
算法与数据结构之图的表示与遍历
weixin_33857230的博客
06-15 276
主要介绍图论的基础、图的两种表示、图的遍历（深度和广度）、一个点到另一点的路径和最短路径等。 原文访问我的技术博客番茄技术小栈-图论 图论基础 图论并不是研究图画。而是研究由节点和边所构成的数学模型 图论抽象模型 万事开头难，虽然看上去很复杂，但是慢慢学习深入之后会体会到他的魅力 很多信息之间的联系都可以使用图来表示。数据可视化 图可以表示的关系 交通运输（每个节点是城市，...
图的概念与遍历
shzxrt的专栏
07-08 693
图是一种较为复杂的数据结构，
图的邻接表表示法及遍历
最新发布
05-17
邻接表是一种图的表示方法，它用链表来表示每个顶点相邻顶点的集合，具体来说，邻接表中每个顶点都对应一个链表，链表中存储该顶点与其它顶点相邻的边的信息，这种方法可以节省存储空间，适用于稀疏图。 以下是邻接表的示例图： ``` 1 -- 2 -- 3 | | 4 -- 5 -- 6 ``` 对应的邻接表如下： ``` 1 -> 2 -> 4 2 -> 1 -> 3 -> 5 3 -> 2 -> 6 4 -> 1 -> 5 5 -> 2 -> 4 -> 6 6 -> 3 -> 5 ``` 图的遍历是指按一定的规则依次访问图中的所有顶点，常用的有深度优先遍历（DFS）和广度优先遍历（BFS）。 深度优先遍历的基本思想是从一个顶点开始，尽可能深地探索每个分支，直到到达最深处，然后回溯到前一个节点，再继续探索其他分支。具体实现可以使用递归或栈来实现。 以下是深度优先遍历的示例代码： ```python def dfs(graph, start): visited = set() # 记录已访问的节点 stack = [start] # 用栈来实现深度优先遍历 while stack: node = stack.pop() # 弹出栈顶节点 if node not in visited: visited.add(node) print(node, end=' ') for neighbor in graph[node]: stack.append(neighbor) ``` 对于上述示例图，从顶点1开始进行深度优先遍历，输出结果为：1 4 5 2 3 6。 广度优先遍历的基本思想是先访问起始顶点的所有邻接顶点，再逐层向外访问其它顶点，具体实现可以使用队列来实现。 以下是广度优先遍历的示例代码： ```python from collections import deque def bfs(graph, start): visited = set() # 记录已访问的节点 queue = deque([start]) # 用队列来实现广度优先遍历 while queue: node = queue.popleft() # 弹出队列头节点 if node not in visited: visited.add(node) print(node, end=' ') for neighbor in graph[node]: queue.append(neighbor) ``` 对于上述示例图，从顶点1开始进行广度优先遍历，输出结果为：1 2 4 3 5 6。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值