数据结构与算法11（B站韩顺平）——图

最新推荐文章于 2024-06-23 11:13:08 发布
最新推荐文章于 2024-06-23 11:13:08 发布
阅读量184 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52253635/article/details/122993808
版权

1 图的基本介绍

1.1 为什么要有图

image-20220216225507941

1.2 图的举例说明

image-20220216225529558

1.3 图的常用概念

image-20220216225608391

image-20220216225616332

2 图的表示方式

2.1 邻接矩阵

image-20220216225709452

2.2 邻接表

image-20220216225745838

3 图的实现

image-20220217225200423

public class Graph {
    private ArrayList<String> vertexList;//存储顶点的集合
    private int[][] edges;//存储图对应的邻接矩阵
    private int numOfEdges;//表示边的数目
    //定义一个数组boolean[],记录某个节点是否被访问过
    private boolean[] isVisited;

    public static void main(String[] args) {
        //测试图是否正确创建
        int n = 5;
        String vertexValue[] = {"A", "B", "C", "D", "E"};
        Graph graph = new Graph(n);
        //循环添加顶点
        for (String value : vertexValue) {
            graph.insertVertex(value);
        }
        //添加边
        //A-B A-C B-C B-D B-E
        graph.insertEdge(0, 1, 1);//A-B
        graph.insertEdge(0, 2, 1);
        graph.insertEdge(1, 2, 1);
        graph.insertEdge(1, 3, 1);
        graph.insertEdge(1, 4, 1);

        //显示邻接矩阵
        graph.showGraph();
    }

    //构造器

    public Graph(int n) {
        //初始化矩阵和vertexList
        edges = new int[n][n];
        vertexList = new ArrayList<>(n);
        numOfEdges = 0;
        isVisited = new boolean[n];
    }

    //返回节点的个数
    public int getNumOfVertex() {
        return vertexList.size();
    }

    //得到边的数目
    public int getNumOfEdges() {
        return numOfEdges;
    }

    //返回节点i（下标）对应的数据  0->"A"  1->"B"
    public String getValueByIndex(int i) {
        return vertexList.get(i);
    }

    //返回v1 v2的权值
    public int getWeight(int v1, int v2) {
        return edges[v1][v2];
    }

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


    //插入顶点
    public void insertVertex(String vertex) {
        vertexList.add(vertex);
    }

    /**
     * 添加边
     *
     * @param v1     表示点的下标，即第几个顶点   "A"-"B"  "A"->0 "B"->1
     * @param v2     第二个顶点的下标
     * @param weight 权值
     */
    public void insertEdge(int v1, int v2, int weight) {
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }
}

运行结果：

[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]

4 深度优先遍历

基本思想

image-20220217225357346

算法步骤

image-20220217225405922

image-20220217225423122

package graph;

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

/**
 * @author Darling yu
 * @version 1.0
 * @date 2022/2/16 22:59
 */
public class Graph {
    private ArrayList<String> vertexList;//存储顶点的集合
    private int[][] edges;//存储图对应的邻接矩阵
    private int numOfEdges;//表示边的数目
    //定义一个数组boolean[],记录某个节点是否被访问过
    private boolean[] isVisited;

    public static void main(String[] args) {
        //测试图是否正确创建
        int n = 5;
        String vertexValue[] = {"A", "B", "C", "D", "E"};
        Graph graph = new Graph(n);
        //循环添加顶点
        for (String value : vertexValue) {
            graph.insertVertex(value);
        }
        //添加边
        //A-B A-C B-C B-D B-E
        graph.insertEdge(0, 1, 1);//A-B
        graph.insertEdge(0, 2, 1);
        graph.insertEdge(1, 2, 1);
        graph.insertEdge(1, 3, 1);
        graph.insertEdge(1, 4, 1);

        //显示邻接矩阵
        graph.showGraph();

        //测试深度优先遍历dfs
        System.out.println("深度遍历~~");
        graph.dfs();

    }

    //构造器

    public Graph(int n) {
        //初始化矩阵和vertexList
        edges = new int[n][n];
        vertexList = new ArrayList<>(n);
        numOfEdges = 0;
        isVisited = new boolean[n];
    }

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

    //根据前一个邻接节点的下标来获取下一个邻接节点
    public int getNextNeighbor(int v1, int v2) {
        for (int j = v2 + 1; j < vertexList.size(); j++) {
            if (edges[v1][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    //深度优先遍历算法
    private void dfs(boolean[] isVisited, int i) {
        //首先访问该节点
        System.out.print(getValueByIndex(i) + "-->");
        //将该节点状态设置为已经访问过
        isVisited[i] = true;
        //找到该节点的第一个邻接节点
        int w = getFirstNeighbor(i);
        while (w != -1) {//说明存在邻接节点
            if (!isVisited[w]) {
                dfs(isVisited, w);
            }
            //如果w这个节点已经被访问过,就查找这个w这个节点的下一个邻接节点
            w = getNextNeighbor(i, w);
        }
    }

    //对dfs进行重载，遍历所有节点，并进行fs
    public void dfs() {
        //遍历所有的节点进行dfs（回溯）
        for (int i = 0; i < getNumOfVertex(); i++) {
            if (!isVisited[i]) {
                dfs(isVisited, i);
            }
        }
    }

    //返回节点的个数
    public int getNumOfVertex() {
        return vertexList.size();
    }

    //得到边的数目
    public int getNumOfEdges() {
        return numOfEdges;
    }

    //返回节点i（下标）对应的数据  0->"A"  1->"B"
    public String getValueByIndex(int i) {
        return vertexList.get(i);
    }

    //返回v1 v2的权值
    public int getWeight(int v1, int v2) {
        return edges[v1][v2];
    }

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


    //插入顶点
    public void insertVertex(String vertex) {
        vertexList.add(vertex);
    }

    /**
     * 添加边
     *
     * @param v1     表示点的下标，即第几个顶点   "A"-"B"  "A"->0 "B"->1
     * @param v2     第二个顶点的下标
     * @param weight 权值
     */
    public void insertEdge(int v1, int v2, int weight) {
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }
}

运行结果：

[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]
深度遍历~~
A-->B-->C-->D-->E-->

5 广度优先遍历

基本思想

image-20220217225737607

算法步骤

image-20220217225818461image-20220217225832465

package graph;

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

/**
 * @author Darling yu
 * @version 1.0
 * @date 2022/2/16 22:59
 */
public class Graph {
    private ArrayList<String> vertexList;//存储顶点的集合
    private int[][] edges;//存储图对应的邻接矩阵
    private int numOfEdges;//表示边的数目
    //定义一个数组boolean[],记录某个节点是否被访问过
    private boolean[] isVisited;

    public static void main(String[] args) {
        //测试图是否正确创建
        int n = 5;
        String vertexValue[] = {"A", "B", "C", "D", "E"};
        Graph graph = new Graph(n);
        //循环添加顶点
        for (String value : vertexValue) {
            graph.insertVertex(value);
        }
        //添加边
        //A-B A-C B-C B-D B-E
        graph.insertEdge(0, 1, 1);//A-B
        graph.insertEdge(0, 2, 1);
        graph.insertEdge(1, 2, 1);
        graph.insertEdge(1, 3, 1);
        graph.insertEdge(1, 4, 1);

        //显示邻接矩阵
        graph.showGraph();

        //测试广度优先
        System.out.println("广度遍历~~");
        graph.bfs();
    }

    //构造器

    public Graph(int n) {
        //初始化矩阵和vertexList
        edges = new int[n][n];
        vertexList = new ArrayList<>(n);
        numOfEdges = 0;
        isVisited = new boolean[n];
    }

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

    //根据前一个邻接节点的下标来获取下一个邻接节点
    public int getNextNeighbor(int v1, int v2) {
        for (int j = v2 + 1; j < vertexList.size(); j++) {
            if (edges[v1][j] > 0) {
                return j;
            }
        }
        return -1;
    }

    //对一个节点进行广度优先遍历的方法
    private void bfs(boolean[] isVisited, int i) {
        int u;//表示队列的头节点对应下标
        int w;//邻接节点的下标
        //队列，记录节点访问的顺序
        LinkedList<Object> queue = new LinkedList<>();
        //访问这个节点，输出
        System.out.print(getValueByIndex(i) + "-->");
        //标记为已访问
        isVisited[i] = true;
        //将这个节点加入队列
        queue.addLast(i);

        while (!queue.isEmpty()) {
            //取出队列的头节点下标
            u = (int) queue.removeFirst();
            //得到第一个邻接节点的下标
            w = getFirstNeighbor(u);
            while (w != -1) {
                //是否访问过
                if (!isVisited[w]) {
                    System.out.print(getValueByIndex(w) + "-->");
                    isVisited[w] = true;
                    //入队
                    queue.addLast(w);
                }
                //以u为前驱节点，找w后面的下一个邻接节点
                w = getNextNeighbor(u, w);//体现广度优先
            }
        }
    }

    //遍历所有节点进行广度优先搜索
    public void bfs() {
        for (int i = 0; i < getNumOfVertex(); i++) {
            if (!isVisited[i]) {
                bfs(isVisited, i);
            }
        }
    }

    //返回节点的个数
    public int getNumOfVertex() {
        return vertexList.size();
    }

    //得到边的数目
    public int getNumOfEdges() {
        return numOfEdges;
    }

    //返回节点i（下标）对应的数据  0->"A"  1->"B"
    public String getValueByIndex(int i) {
        return vertexList.get(i);
    }

    //返回v1 v2的权值
    public int getWeight(int v1, int v2) {
        return edges[v1][v2];
    }

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


    //插入顶点
    public void insertVertex(String vertex) {
        vertexList.add(vertex);
    }

    /**
     * 添加边
     *
     * @param v1     表示点的下标，即第几个顶点   "A"-"B"  "A"->0 "B"->1
     * @param v2     第二个顶点的下标
     * @param weight 权值
     */
    public void insertEdge(int v1, int v2, int weight) {
        edges[v1][v2] = weight;
        edges[v2][v1] = weight;
        numOfEdges++;
    }
}

运行结果：

[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]
广度遍历~~
A-->B-->C-->D-->E-->

image-20220217230312388

/**
* 添加边
*
* @param v1 表示点的下标，即第几个顶点 “A”-“B” “A”->0 “B”->1
* @param v2 第二个顶点的下标
* @param weight 权值
*/
public void insertEdge(int v1, int v2, int weight) {
edges[v1][v2] = weight;
edges[v2][v1] = weight;
numOfEdges++;
}
}


运行结果：

```java
[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]
广度遍历~~
A-->B-->C-->D-->E-->

[外链图片转存中…(img-Uky2gbSK-1645110412899)]

Darling yu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
韩顺平 数据结构与算法 （16） 图
weixin_52184392的博客
11-01 115
图 为什么要有图？ 我们有线性表和树 线性表局限于一个直接前驱和一个直接后继的关系 树也只能有一个直接前驱也就是父节点 当我们需要表示多对多的关系时，这里我们就用到了图 1）基本介绍 图是一种数据结构，其中节点可以具有零个或者多个相邻元素。两个节点之间的连接称为边。节点也可以称为顶点。 2）常用概念 顶点（vertex） 边（edge） 路径（例如：D->A->B->C ; D->B->C） 无向图（顶点之间的连接没有方向） 有向图（顶点之间的连接有方向） 带
韩顺平老师尚硅谷Java数据结构与算法194集笔记
10-12
这是我从B站上看韩老师讲的数据结构与算法后整理的笔记 代码经过运行，欢迎批评指正 有些地方我感觉还是挺难的 大都经过我自己的语言进行描述，韩老师中期的表达可能或多或少也影响可阅读性，望先生们见谅
数据结构与算法13（B站韩顺平）——分治算法
weixin_52253635的博客
02-19 342
1 介绍 2 分治算法的基本步骤 3 分治算法设计模式 4 分治算法实践——汉诺塔 汉诺塔思路分析： 代码： public class Hanoitower { public static void main(String[] args) { hanoiTower(5, 'A', 'B', 'C'); } //汉诺塔的移动方案 //使用分治算法 //把所有盘a-->c 移动过程使用到b public static void h
【数据结构与算法】尚硅谷韩顺平老师+含java代码(更新中)
weixin_67937439的博客
05-09 1527
数据结构 数据结构是计算机存储、组织数据的方式,指相互之间存在一种或多种特定关系的数据元素的集合。 通常情况下,精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关
数据结构与算法10（B站韩顺平）——多路查找树
weixin_52253635的博客
02-16 150
数据结构与算法10（B站韩顺平）——多路查找树 1 二叉树与B树 1.1 二叉树的问题分析 1.2 多叉树 1.3 B树的基本介绍 2 2-3树 2.1 介绍 2.2 2-3树应用案例 2.3 其他说明 3 B树、B+树、B*树 图片转存中…(img-gYg6DS4B-1645020035904)] ...
数据结构与算法12（B站韩顺平）——二分查找算法（非递归）
weixin_52253635的博客
02-17 99
1 介绍 2 实现 package binarysearchnoresursion; /** * @author Darling yu * @version 1.0 * @date 2022/2/17 23:13 */ public class BinarySearchNoRecursion { public static void main(String[] args) { int[] arr = {1, 3, 8, 10, 11, 67, 100}; //
Java数据结构与算法（韩顺平老师）自学笔记
三驴蛋蛋的博客
04-25 3388
数据类型 1 数据类型介绍 数据类型的分类（按照结构划分）：线性结构和非线性结构 线性结构
数据结构与算法——Java语言实现
m0_53127728的博客
05-01 324
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、插入排序、快速排序、归并排序、希尔排序、基数排序(桶排序)、堆排序、排序速度分析、二分查找、插值查找、斐波那契查找、散列、哈希表、二叉树、二叉树与数组转换、二叉排序树(BST)等。
韩顺平JAVA数据结构与算法，重点是算法！.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
【CS.DS】数据结构 —— 图：深入了解三种表示方法之邻接表(Adjacency List)
Charlie_Lee_CS的博客
06-20 1208
在邻接表表示法中，链表中顶点的顺序实际上是不重要的。邻接表的主要目的是表示每个顶点的邻接关系以及对应的边权重，因此，顶点的顺序并不会影响图的表示和算法的正确性。总体来看，第二种封装方式更符合现代 C++ 编程规范，更加推荐。简洁性和可维护性：使用 STL 容器使代码更简洁，易于维护和扩展。内存管理：STL 容器自动管理内存，减少内存泄漏的风险。灵活性：STL 容器提供了丰富的操作接口，使用更加灵活。当然, 如果你需要对图进行非常细粒度的控制，或者在非常严格的性能要求下，第一种封装方式可能更适合。
数据结构小知识2：树
jialuosi的博客
06-18 855
数据结构中的树是一种非常重要的非线性数据结构。它由节点（Node）和边（Edge）组成，用于表示具有层次关系的数据。
图(数据结构篇)
最新发布
hellmorning的博客
06-23 387
讲述数据结构中的图
5.数据结构-树
mj256115的博客
06-19 721
数据结构中的树是一种抽象数据类型，它是由节点组成的层次结构。树的每个节点可以包含零个或多个子节点，但只能有一个父节点（除了根节点，它没有父节点）。以下是树的一些基本概念和特性：树的操作可以通过多种编程语言实现。以下是使用Python语言实现的树的一些基本操作的示例代码。我们将以二叉树为例，展示如何创建树节点、插入节点、搜索节点、删除节点以及遍历树。 插入节点 搜索节点 删除节点 删除节点是树操作中较为复杂的部分，需要考虑多种情况，这里给出一个简化的版本： 遍历树 前序遍历 中序遍历 后序遍历 层序
【数据结构】选择题
`雾博客
06-19 618
设高为h的二叉树（规定叶子结点的高度为1）只有度为0和2的结点，则此类二叉树的最少结点数和最多结点数分别为（2h−1, 2^h −1）通常要求同一逻辑结构中的所有数据元素具有相同的特性，这意味着（不仅数据元素所包含的数据项的个数要相同，而且对应的数据项的类型要一致）假设有5个整数以1、2、3、4、5的顺序被压入堆栈，且出栈顺序为3、5、4、2、1，那么为了获得这样的输出，堆栈大小至少为（4）在计算机的存储器中表示时，逻辑上相邻的两个元素对应的物理地址也是相邻的，这种存储结构称之为（顺序存储结构）
二叉查找树(数据结构篇)
hellmorning的博客
06-19 275
讲解数据结构之二叉查找树(二叉排序树)
数据结构：4.1.1二叉搜素树及查找
Aufidius的博客
06-19 162
实现的方式不仅是递归而且是尾递归， 即程序最后要返回的时候递归，从遍历的角度讲尾递归都可以用循环来实现。静态查找：要找的集合的元素是不动的，主要是find操作，没有delete操作。所以我们喜欢的是平衡一点的树，这就是之后要学的二叉平衡树。Find函数两个参数，一个要查找的元素X，一个树BST。而 对同样的n个结点来说，查找的效率又与树的结构有关。动态查找：要查找的集合会经常发生插入删除的操作。结点右子树的值>结点的值>结点左子树的值。静态查找的一个很好的方法就是二分查找。为什么这两个程序的写法不一样啊？
算法与数据结构--决策树算法
考研小钻风
06-16 1325
决策树算法在数据科学和机器学习中具有重要地位，理解其原理和实现方法对解决实际问题具有重要意义。
韩顺平数据结构与算法
08-25
韩顺平是一位在B站上讲解数据结构与算法的老师，他的课程非常受欢迎。我在您提供的引用中看到了他的一些代码示例。其中，引用是对他课程的学习笔记的整理，引用是一个关于汉诺塔移动的分治算法示例，引用则是一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值