图

最新推荐文章于 2024-10-16 07:16:00 发布
最新推荐文章于 2024-10-16 07:16:00 发布
阅读量50 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48776531/article/details/129908565
版权
本文介绍了图的基本概念，包括顶点、边和无向图等，详细讲解了图的两种表示方式——邻接矩阵和邻接表，并提供了入门案例。接着，文章深入探讨了深度优先遍历和广度优先遍历的遍历思路、算法步骤及代码示例，展示了如何在Java中实现这两种遍历方法。
摘要由CSDN通过智能技术生成

章节目录：

一、图的相关概念

1.1 基本介绍

为什么要有图？

  • 线性表局限于一个直接前驱和一个直接后继的关系；
  • 树也只能有一个直接前驱也就是父节点；
  • 当我们需要表示多对多的关系时， 这里我们就用到了图。

1.2 举例说明

  • 图是一种数据结构，其中节点可以具有零个或多个相邻元素。两个节点之间的连接称为边，节点也可以称为顶点。
  • 示意图：

在这里插入图片描述

1.3 常用概念

  • 顶点（vertex）
  • 边（edge）
  • 路径
  • 无向图
  • 有向图
  • 带权图

在这里插入图片描述

二、图的表示方式

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

2.1 邻接矩阵

  • 邻接矩阵是表示图形中顶点之间相邻关系的矩阵，对于 n 个顶点的图而言，矩阵是的 row 和 col 表示的是 1…n 个点。

  • 示意图：

在这里插入图片描述

2.2 邻接表

  • 邻接矩阵需要为每个顶点都分配 n 个边的空间，其实有很多边都是不存在的，会造成空间的一定损失。
  • 邻接表的实现只关心存在的边，不关心不存在的边，因此没有空间浪费，邻接表由数组+链表组成 。
  • 示意图：

在这里插入图片描述

三、入门案例

需求：实现如下图的结构。

  • 示意图：

在这里插入图片描述

  • 思路分析：
    • 使用集合存储顶点；
    • 通过二维数组保存矩阵。
  • 代码示例：
public class GraphDemo {


    public static void main(String[] args) {
        // 顶点元素。
        String[] vertexes = {"A", "B", "C", "D", "E"};
        
        // 5个顶点的图。
        Graph graph = new Graph(5);
        
        // 循环的添加顶点。
        for (String vertex : vertexes) {
            graph.insertVertex(vertex);
        }
        
        // 手动添加边：
        // A-B A-C B-C B-D B-E
        graph.insertEdge(0, 1, 1); // A-B（A下标0；B下标1；有连接则权值1）
        graph.insertEdge(0, 2, 1); // A-C（A下标0；C下标2；有连接则权值1）
        graph.insertEdge(1, 2, 1); // 其它同理....
        graph.insertEdge(1, 3, 1); //
        graph.insertEdge(1, 4, 1); //

        // 显示添加结果。
        graph.showGraph();
        // [0, 1, 1, 0, 0]
        // [1, 0, 1, 1, 1]
        // [1, 1, 0, 0, 0]
        // [0, 1, 0, 0, 0]
        // [0, 1, 0, 0, 0]
    }
}

class Graph {

    /**
     * 存储顶点集合。
     */
    List<String> vertexes;

    /**
     * 存储图对应的邻结矩阵。
     */
    int[][] edges;

    /**
     * 表示边的数目。
     */
    int numOfEdges;

    /**
     * 图的构造器。
     *
     * @param n 表示 n 个顶点。
     */
    public Graph(int n) {
        this.edges = new int[n][n];
        this.vertexes = new ArrayList<>();
        this.numOfEdges = 0;
    }

    /**
     * 显示图对应的矩阵。
     */
    public void showGraph() {
        for (int[] link : edges) {
            System.out.println(Arrays.toString(link));
        }
    }

    /**
     * 插入顶点。
     *
     * @param vertex 顶点
     */
    public void insertVertex(String vertex) {
        vertexes.add(vertex);
    }

    /**
     * 添加边。
     *
     * @param v1     表示点的下标即是第几个顶点  举例：假设要表示"A"、"B"，则元素"A"对应的下标是0；元素"B"对应的下标是1
     * @param v2     第二个顶点对应的下标
     * @param weight 表示权值 (这里使用0表示无连接；1表示有直线连接。)
     */
    public void insertEdge(int v1, int v2, int weight) {
        // 因为是无向图，则需要进行双向添加权值。
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }
}

四、深度优先遍历

4.1 基本介绍

  • 所谓图的遍历，即是对节点的访问，一个图有那么多个节点，如何遍历这些节点，需要特定策略。

  • 一般有两种访问策略：它们分别是深度优先遍历、广度优先遍历 。

4.2 遍历思路

图的深度优先搜索（Depth First Search）。

  • 深度优先遍历，从初始访问节点出发，初始访问节点可能有多个邻接节点，深度优先遍历的策略就是首先访问第一个邻接节点，然后再以这个被访问的邻接节点作为初始节点，访问它的第一个邻接节点（可以这样理解：每次都在访问完当前节点后，首先访问当前节点的第一个邻接节点）。
  • 我们可以看到，这样的访问策略是优先往纵向挖掘深入，而不是对一个节点的所有邻接节点进行横向访问。
  • 显然，深度优先搜索是一个递归的过程。

4.3 算法步骤

  1. 访问初始节点，并标记该节点为已访问；
  2. 查找该节点的第一个邻接节点；
  3. 若存在邻接节点，则继续执行下面步骤，如果不存在，则回到第 1 步，将从初始节点的下一个节点继续；
  4. 若邻接节点未被访问，对该节点进行深度优先遍历递归（即把当前邻接节点当做另一个初始节点，然后进行步骤 123）；
  5. 查找已访问邻接节点的下一个邻接节点，转到步骤 3。
  • 示意图：

在这里插入图片描述

4.4 代码示例

    /**
     * 深度优先遍历。
     *
     * @param isVisited 标记是否被访问的数组
     * @param i         下标
     */
    private void dfs(boolean[] isVisited, int i) {
        // 访问并输出节点。
        System.out.print(vertexes.get(i) + "->");
        // 设置为已访问。
        isVisited[i] = true;
        // 查找节点 i 的第一个邻接节点 n 。
        int n = getFirstNeighbor(i);
        // 存在这样一个邻接节点。
        while (-1 != n) {
            if (!isVisited[n]) {
                dfs(isVisited, n);
            }
            // 如果 n 节点已经被访问过。
            n = getNextNeighbor(i, n);
        }
    }

    /**
     * 重载 dfs 方法。
     * 目的：对所有节点进行 dfs 。
     */
    public void dfs() {
        isVisited = new boolean[vertexes.size()];
        for (int i = 0; i < vertexes.size(); i++) {
            if (!isVisited[i]) {
                // 回溯。
                dfs(isVisited, i);
            }
        }
    }

五、广度优先遍历

5.1 遍历思路

图的广度优先搜索(Broad First Search)。

  • 类似于一个分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的节点的顺序，以便按这个顺序来访问这些节点的邻接节点。

5.2 算法步骤

  1. 访问初始节点，并标记该节点为已访问；
  2. 将已访问的初始节点加入队列（记录访问顺序）；
  3. 当队列非空时，继续执行，否则对于该节点执行的算法结束；
  4. 出队列，取出队头节点；
  5. 查找队头节点的第一个邻接节点；
  6. 若队头节点的邻接节点不存在，则转到步骤 3；否则循环执行以下三个步骤：
    1. 若邻接节点尚未被访问，则访问该节点并标记为已访问；
    2. 该邻接节点入队列（记录访问顺序）；
    3. 查找该邻接节点的下一个邻接节点，转到步骤 6。
  • 示意图：

在这里插入图片描述

5.3 代码示例

    /**
     * 广度优先遍历。
     *
     * @param isVisited 标记是否被访问的数组
     * @param i         下标
     */
    private void bfs(boolean[] isVisited, int i) {
        // 访问并标记为已访问。
        System.out.print(vertexes.get(i) + "->");
        isVisited[i] = true;
        // 入队列，用于记录顶点访问的顺序。
        LinkedList<Integer> queue = new LinkedList<>();
        queue.addLast(i);

        // 表示队列的头顶点对应下标。
        int h;
        // 邻接顶点。
        int n;
        while (!queue.isEmpty()) {
            // 取出队列的头顶点下标。
            h = queue.removeFirst();
            // 得到第一个邻接顶点的下标。
            n = getFirstNeighbor(h);
            // 找到。
            while (-1 != n) {
                //是否访问过。
                if (!isVisited[n]) {
                    System.out.print(vertexes.get(n) + "->");
                    //标记已经访问。
                    isVisited[n] = true;
                    //入队。
                    queue.addLast(n);
                }
                // 以头顶点为前驱点，找邻接顶点后面的下一个邻接顶点。
                n = getNextNeighbor(h, n);
            }
        }
    }

    /**
     * 重载 bfs 方法。
     * 目的：遍历所有的顶点，并进行 bfs 。
     */
    public void bfs() {
        isVisited = new boolean[vertexes.size()];
        for (int i = 0; i < vertexes.size(); i++) {
            if (!isVisited[i]) {
                // 回溯。
                bfs(isVisited, i);
            }
        }
    }

六、完整示例代码

需求：通过深度优先遍历和广度优先遍历两种方式，对由元素{“1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”}组成的图，进行遍历。

  • 示意图：

在这里插入图片描述

  • 代码示例：
public class GraphDemo {

    public static void main(String[] args) {
        String[] vertexes = {"1", "2", "3", "4", "5", "6", "7", "8"};
        // 8个顶点的图。
        Graph graph = new Graph(8);
        // 循环的添加顶点。
        for (String vertex : vertexes) {
            graph.insertVertex(vertex);
        }

        // 手动更新边的关系。
        graph.insertEdge(0, 1, 1);
        graph.insertEdge(0, 2, 1);
        graph.insertEdge(1, 3, 1);
        graph.insertEdge(1, 4, 1);
        graph.insertEdge(3, 7, 1);
        graph.insertEdge(4, 7, 1);
        graph.insertEdge(2, 5, 1);
        graph.insertEdge(2, 6, 1);
        graph.insertEdge(5, 6, 1);

        // 显示添加结果。
        graph.showGraph();
        // [0, 1, 1, 0, 0, 0, 0, 0]
        // [1, 0, 0, 1, 1, 0, 0, 0]
        // [1, 0, 0, 0, 0, 1, 1, 0]
        // [0, 1, 0, 0, 0, 0, 0, 1]
        // [0, 1, 0, 0, 0, 0, 0, 1]
        // [0, 0, 1, 0, 0, 0, 1, 0]
        // [0, 0, 1, 0, 0, 1, 0, 0]
        // [0, 0, 0, 1, 1, 0, 0, 0]

        System.out.println("深度遍历：");
        graph.dfs();
        // 深度遍历：
        // 1->2->4->8->5->3->6->7->
        System.out.println();
        System.out.println("广度优先：");
        graph.bfs();
        // 广度优先：
        // 1->2->3->4->5->6->7->8->
    }
}

class Graph {

    /**
     * 存储顶点集合。
     */
    List<String> vertexes;

    /**
     * 存储图对应的邻结矩阵。
     */
    int[][] edges;

    /**
     * 表示边的数目。
     */
    int numOfEdges;

    /**
     * 记录某个顶点是否被访问。
     */
    boolean[] isVisited;

    /**
     * 图的构造器。
     *
     * @param n 表示 n 个顶点。
     */
    public Graph(int n) {
        this.edges = new int[n][n];
        this.vertexes = new ArrayList<>();
        this.numOfEdges = 0;
    }

    /**
     * 显示图对应的矩阵。
     */
    public void showGraph() {
        for (int[] link : edges) {
            System.out.println(Arrays.toString(link));
        }
    }

    /**
     * 插入顶点。
     *
     * @param vertex 顶点
     */
    public void insertVertex(String vertex) {
        vertexes.add(vertex);
    }

    /**
     * 添加边。
     *
     * @param v1     表示点的下标即是第几个顶点  举例：假设要表示"A"、"B"，则元素"A"对应的下标是0；元素"B"对应的下标是1
     * @param v2     第二个顶点对应的下标
     * @param weight 表示权值 (这里使用1表示有直线连接；0表示无连接。)
     */
    public void insertEdge(int v1, int v2, int weight) {
        // 因为是无向图，则需要进行双向添加权值。
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }

    /**
     * 得到第一个邻接顶点的下标。
     *
     * @param index 下标
     * @return int 如果存在就返回对应的下标，否则返回-1
     */
    public int getFirstNeighbor(int index) {
        for (int j = 0; j < vertexes.size(); j++) {
            if (edges[index][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    /**
     * 根据前一个邻接顶点的下标来获取下一个邻接顶点。
     *
     * @param v1 下标1
     * @param v2 下标2
     * @return int 如果存在就返回对应的下标，否则返回-1
     */
    public int getNextNeighbor(int v1, int v2) {
        for (int j = (v2 + 1); j < vertexes.size(); j++) {
            if (edges[v1][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    /**
     * 深度优先遍历。
     *
     * @param isVisited 标记是否被访问的数组
     * @param i         下标
     */
    private void dfs(boolean[] isVisited, int i) {
        // 访问并输出顶点。
        System.out.print(vertexes.get(i) + "->");
        // 设置为已访问。
        isVisited[i] = true;
        // 查找顶点 i 的第一个邻接顶点 n 。
        int n = getFirstNeighbor(i);
        // 存在这样一个邻接顶点。
        while (-1 != n) {
            if (!isVisited[n]) {
                dfs(isVisited, n);
            }
            // 如果 n 顶点已经被访问过。
            n = getNextNeighbor(i, n);
        }
    }

    /**
     * 重载 dfs 方法。
     * 目的：遍历所有的顶点，并进行 dfs 。
     */
    public void dfs() {
        isVisited = new boolean[vertexes.size()];
        for (int i = 0; i < vertexes.size(); i++) {
            if (!isVisited[i]) {
                // 回溯。
                dfs(isVisited, i);
            }
        }
    }

    /**
     * 广度优先遍历。
     *
     * @param isVisited 标记是否被访问的数组
     * @param i         下标
     */
    private void bfs(boolean[] isVisited, int i) {
        // 访问并标记为已访问。
        System.out.print(vertexes.get(i) + "->");
        isVisited[i] = true;
        // 入队列，用于记录顶点访问的顺序。
        LinkedList<Integer> queue = new LinkedList<>();
        queue.addLast(i);

        // 表示队列的头顶点对应下标。
        int h;
        // 邻接顶点。
        int n;
        while (!queue.isEmpty()) {
            // 取出队列的头顶点下标。
            h = queue.removeFirst();
            // 得到第一个邻接顶点的下标。
            n = getFirstNeighbor(h);
            // 找到。
            while (-1 != n) {
                //是否访问过。
                if (!isVisited[n]) {
                    System.out.print(vertexes.get(n) + "->");
                    //标记已经访问。
                    isVisited[n] = true;
                    //入队。
                    queue.addLast(n);
                }
                // 以头顶点为前驱点，找邻接顶点后面的下一个邻接顶点。
                n = getNextNeighbor(h, n);
            }
        }
    }

    /**
     * 重载 bfs 方法。
     * 目的：遍历所有的顶点，并进行 bfs 。
     */
    public void bfs() {
        isVisited = new boolean[vertexes.size()];
        for (int i = 0; i < vertexes.size(); i++) {
            if (!isVisited[i]) {
                // 回溯。
                bfs(isVisited, i);
            }
        }
    }
}

七、结束语

“-------怕什么真理无穷,进一寸有一寸的欢喜。”

微信公众号搜索：饺子泡牛奶。

饺子泡牛奶
关注
专栏目录
图片轮播html原生代码,原生js实现轮播图的示例代码
weixin_32075745的博客
05-31 2307
很多网站上都有轮播图，但却很难找到一个系统讲解的，因此这里做一个简单的介绍，希望大家都能有所收获，如果有哪些不正确的地方，希望大家可以指出。原理：将一些图片在一行中平铺，然后计算偏移量再利用定时器实现定时轮播。步骤一：建立html基本布局如下所示：轮播图 12345<>只有五张图片，却使用7张来轮播，这是...
java图片覆盖_java使用Graphics2D图片叠加
weixin_39929138的博客
02-12 632
/*** 图片覆盖(覆盖图压缩到width*height大小，覆盖到底图上)** @param baseFilePath 底图* @param coverFilePath 覆盖图* @param x 起始x轴* @param y 起始y轴* @param width 覆盖宽度* @param height 覆盖长度度* @return* @throws Exception*/public stat...
typora两张图片并排显示
hello, coder~
03-03 966
Typora图片并排显示。
uniapp实现图片上传
sk19969306105的博客
08-18 1万+
我最开始也不是很理解为什么明明这两个路径是后端给我的，难道后端自己在往DB里存的时候就不能获取吗。之后和后端的哥们讨论了一下，他的解释是：完全可以做到，但是如果把接受解析上传的图片资源，生成路径，再把路径存到DB中，最后到前端接受到成功的信息，这一套下来用户需要等待大量（可能吧）的时间，所以为了提升用户体验，尽量不要把所有的处理都放在这一次事件里做。后端会解析拿到的图片资源并返回一个临时路径和绝对路径，在成功的回调中给。因为只有一张图片，所以直接用的字符串，如果需要多张，可以用数组做v-for。......
js将图片转字符图
weixin_45435140的博客
09-08 1637
如何获取图片每一个像素点的rgb颜色值/将图片转换成字符图/获取图片颜色数据/js将图片转字符图
C++读取图片
热门推荐
Learning
11-20 5万+
C++读取图片 以C++风格（文件流）而不是C风格（FILE）读取图片。 使用到的头文件主要是fstream 参考链接： http://www.cplusplus.com/reference/istream/istream/read/ 主要用到的函数： ifstream.seekg() ifstream.tellg() ifstream.read() 主要步骤： 打开图片文件 计算图片长度...
PPT图片高清导出
qq_52785898的博客
05-19 1254
高清导出PPT制作的图片（Windows系统上亲测有效）
Stemwin如何显示背景透明的图片
qq_15181569的博客
05-21 1349
1、首先找到一张背景透明的图片用BmpCvtST软件打开，如何判断图片有没有透明背景呢，用软件打开以后灰色的就是透明背景，如下图。说明一点png格式的图片才会有透明背景 用图片查看器打开也是灰色的，如下图： 2、BmpCvtST设置 a.选择image -> convert to ->best palette+transprant 此时背景会由灰色变成白色，如下图： b.设置透明颜色。一般情况下用背景的白色比较好，选择颜色代码0xffffff。（如果图片背景是纯蓝纯红，那就设定透明颜色
【以图搜图】Python实现根据图片批量匹配(查找)相似图片
Joker_Q的博客
08-01 6499
可以解决在本地实现根据图片查找相似图片的功能
iTextSharp 添加图片
记录
04-23 1807
添加图片 //参数为 图片路径 Image image = Image.GetInstance("72.jpg"); document.Add(image); 设置图片尺寸 //原图尺寸的0.3 image.ScalePercent(30f); //设置图片的宽高 image.ScaleAbsolute(450f, 300f); 设置图片位置 //图片居中 image.Alignment = Element.ALIGN_CENTER; //设置图片具体位置 PDF左下角为原点 image.
C# winform 图片定位 图片相似度匹配 查询图1在图2中的位置
05-06
图片定位主要是确定一张小图片（查询图）在大图片（背景图）中的精确位置。通常，这涉及到图像特征匹配、模板匹配或基于深度学习的方法。在WinForm应用中，我们可以使用OpenCV库，这是一个强大的跨平台计算机视觉库...
点击图片弹出大图效果交互
08-03
在网页设计中，点击图片弹出大图效果是一种常见的交互设计，它为用户提供了一种查看高清晰度图像的便捷方式。这种效果通常通过JavaScript（JS）实现，因为JS具有动态控制网页元素的能力，可以轻松地处理用户的点击...
图像处理经典标准图片lena图等
07-09
在图像处理领域，经典的标准图片是用来测试和展示各种算法效果的重要工具。这些图片因其特性而被广泛使用，比如它们的复杂性、清晰度或者颜色分布。"lena"图是其中最为著名的代表之一，它在图像处理的历史上占据了...
微信小程序上传图片包含多图上传，支持9图，无限制图片数目
02-23
本篇文章将深入探讨微信小程序如何实现多图上传，包括单图上传、9图上传以及无限制图片数目的上传策略。 首先，我们要了解微信小程序中的`wx.chooseImage`接口，这是用于选择本地相册或拍照获取图片的关键函数。它...
基于VUE选择上传图片并页面显示（图片可删除）
08-30
基于VUE选择上传图片并页面显示（图片可删除） 本资源主要介绍了基于VUE选择上传图片并页面显示的效果，图片可以删除。该效果通过VUE框架实现图片上传和显示，并提供了删除图片的功能。下面我们将对该资源的知识点...
数据结构与算法：高级数据结构与实际应用
最新发布
weidl001的博客
10-16 1111
本章介绍了跳表、Trie树、B树与 B+树等高级数据结构，以及它们在实际系统中的应用。这些数据结构在提高查找效率、优化存储和加速特定任务方面具有不可替代的作用。通过深入理解这些结构及其特性，我们能够选择最合适的数据结构来应对复杂的实际问题。在下一章中，我们将深入讨论并查集与线段树的高级应用，以及它们在图论和范围查询中的重要作用。
【数据结构】AVL树（C++实现）
weixin_73914025的博客
10-13 763
二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。它的左右子树都是AVL树左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1)如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在Olog2nO(log_2 n)Olog。
《C++中栈的实现：探索高效数据结构》
xy520521的博客
10-13 607
当向栈中添加元素时，创建一个新的节点，将其数据设置为要添加的元素，并将其指向下一个节点设置为当前的栈顶节点，然后将栈顶指针指向新节点。当从栈中删除元素时，将栈顶指针指向当前栈顶节点的下一个节点，并释放原来栈顶节点的内存。首先，数组的大小是固定的，一旦栈的大小超过了数组的容量，就需要进行复杂的扩容操作。其次，数组实现的栈在内存中的分配是连续的，可能会导致内存碎片的问题。此外，链表实现的栈在内存中的分配是不连续的，不会产生内存碎片。但是，链表实现的栈在进行插入和删除操作时需要进行指针的操作，相对来说比较复杂。
数据结构——栈
2301_76227083的博客
10-14 724
简单介绍了栈是什么，以及如何用C语言实现一个栈
JavaScript 图片类型检测函数
在给定的代码示例中，我们看到一个JavaScript函数`isImg()`，它的主要目的是判断用户通过`<input type="file">`选择的文件是否是图片类型。这个函数对于防止非法文件上传、维护网站安全和提供良好的用户体验至关重要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值