图的笔记

最新推荐文章于 2024-01-15 18:00:51 发布
最新推荐文章于 2024-01-15 18:00:51 发布
阅读量123 收藏
点赞数
分类专栏： Java数据结构与算法笔记 文章标签： 算法 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43906881/article/details/109300643
版权

图

基本介绍

为什么要有图

  1. 前面我们学了线性表和树

  2. 线性表局限于一个直接前驱和一个直接后继的关系

  3. 树也只能有一个直接前驱也就是父节点

  4. 当我们需要 表示多对多的关系时， 这里我们就用到了图.

图的举例说明

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

图的常用概念

  1. 顶点(vertex)

  2. 边(edge)

  3. 路径

  4. 无向图(右图

在这里插入图片描述

  1. 有向图

  2. 带权图

在这里插入图片描述

图的表示方式

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

邻接矩阵

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

在这里插入图片描述

邻接表

  1. 邻接矩阵需要为每个顶点都分配 n 个边的空间，其实有很多边都是不存在,会造成空间的一定损失.

  2. 邻接表的实现只关心存在的边，不关心不存在的边。因此没有空间浪费，邻接表由数组+链表组成

  3. 举例说明， 如图：

在这里插入图片描述

图的基本创建

  1. 要求: 代码实现如下图结构.

在这里插入图片描述

  1. 思路分析 (1) 存储顶点 String 使用 ArrayList (2) 保存矩阵 int[][] edges
  1. 代码实现
public class Graph {
    private ArrayList<String> vertexList;//存储定点集合
    private int[][] edges; //存储图对应的邻接矩阵
    private int numOfEdges; // 表示边的数目
    
    public static void main(String[] args) {
        //测试图的创建
        int n = 5; //节点的个数
        String VertexValue[] = {"A","B","C","D","E"};
        //创建图对象
        Graph graph = new Graph(n);
        //循环的添加节点
        for (String vertex :
                VertexValue) {
            graph.insertVertex(vertex);
        }

        //添加边
        //A-B A-C B-C B-D B-E
        graph.insertEdge(0,1,1); //A-B
        graph.insertEdge(0,2,1); //A-C
        graph.insertEdge(1,2,1); //B-C
        graph.insertEdge(1,3,1); //B-D
        graph.insertEdge(1,4,1); //B-E

        //显示矩阵
        graph.showGraph();
    }
    
    //构造器
    public Graph(int n){
        //初始化矩阵 和 vertexList
        edges = new int[n][n];
        vertexList = new ArrayList<>();
        numOfEdges = 0;
    }
    
    //图中常用的方法
    //显示图对应的邻接矩阵
    public void showGraph(){
        for (int[] link :
                edges) {
            System.out.println(Arrays.toString(link));
        }
    }
    //得到边的数目
    public int getNumOfEdges(){
        return numOfEdges;
    }
    //返回节点的个数
    public int getNumOfVertex(){
        return vertexList.size();
    }
    //返回节点i（下标） 对应的数据 0 -> "A" 1 -> "B" 2 -> "C"
    public String getValueByIndex(int i){
        return vertexList.get(i);
    }
    //返回v1 和 v2 的权值
    public int getWeight(int v1,int v2){
        return edges[v1][v2];
    }
    //插入节点
    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]

图的深度优先遍历（dfs）算法

基本介绍

所谓图的遍历，即是对结点的访问。一个图有那么多个结点，如何遍历这些结点，需要特定策略，一般有两种
访问策略: (1)深度优先遍历 (2)广度优先遍历

图的深度优先搜索(Depth First Search) 。

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

算法步骤

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

在这里插入图片描述

代码实现(核心)

//深度优先遍历算法（dfs）
// i  第一次就是 0
private void dfs(boolean[] isVisited, int i){
    //首先我们访问该节点， 输出
    System.out.print(getValueByIndex(i)+"->");
    //将节点设置为已访问
    isVisited[i] = true;
    //查找邻接节点i的 第一个 邻接节点w
    int w = getFirstNeighbor(i);
    while (w != -1){// 说明 i 有邻接节点
        if (!isVisited[w]) {
            dfs(isVisited, w);
        }else {
            //如果w已经被访问过了
            w = getNextNeighbor(i,w);
        }
    }
}

//对dfs进行一个重载， 遍历我们所有的节点， 并进行dfs
public void dfs(){
    isVisited = new boolean[getNumOfVertex()];
    //遍历所有的节点， 进行dfs【回溯】
    for (int i = 0; i < getNumOfVertex(); i++) {
        if (!isVisited[i]){
            dfs(isVisited,i);
        }
    }
}

运行结果：

深度优先遍历：
A->B->C->D->E->

图的广度优先遍历（bfs）算法

基本介绍

  1. 图的广度优先搜索(Broad First Search) 。
  2. 类似于一个 分层搜索的过程，广度优先遍历需要使用一个队列以保持访问过的结点的顺序，以便按这个顺序来
    访问这些结点的邻接结点

算法步骤

  1. 访问初始结点 v 并标记结点 v 为已访问。
  2. 结点 v 入队列
  3. 当队列非空时，继续执行，否则算法结束。
  4. 出队列，取得队头结点 u。
  5. 查找结点 u 的第一个邻接结点 w。
  6. 若结点 u 的邻接结点 w 不存在，则转到步骤 3；否则循环执行以下三个步骤：
    6.1 若结点 w 尚未被访问，则访问结点 w 并标记为已访问。
    6.2 结点 w 入队列
    6.3 查找结点 u 的继 w 邻接结点后的下一个邻接结点 w，转到步骤 6。

在这里插入图片描述

代码实现（核心）

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

    while (! queue.isEmpty()){
        //取出队列的头结点的下标
        u = (Integer)queue.removeFirst();
        //得到第一个邻接节点的下标w
        w = getFirstNeighbor(u);
        //注： 在这个while循环里， 我们将完成对（以A节点为例）目标节点的所有邻接节点的访问
        while (w != -1){ //找到
            //是否访问过
            if (!isVisited[w]){
                System.out.print(getValueByIndex(w)+"=>");
                //标记为已访问
                isVisited[w] = true;
                //入队
                queue.addLast(w);
            }else {
                //寻找u节点除了w节点以外的别的邻接节点
                // （若u以 A 的下标0为例， 则第一轮循环执行这条语句之前的的w就是 1（B），执行之后就是 2（C））
                w = getNextNeighbor(u,w);
            }
        }
    }
}

//对bfs进行一个重载， 遍历我们所有的节点， 都进行bfs
public void bfs(){
    isVisited = new boolean[getNumOfVertex()];
    for (int i = 0; i < getNumOfVertex(); i++) {
        if (!isVisited[i]){
            bfs(isVisited,i);
        }
    }
}

运行结果：

广度优先遍历：
A=>B=>C=>D=>E=>

图的代码实现（汇总）

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; //节点的个数
        int n = 8;
        //String VertexValue[] = {"A","B","C","D","E"};
        String VertexValue[] = {"1", "2", "3", "4", "5", "6", "7", "8"};
        //创建图对象
        Graph graph = new Graph(n);
        //循环的添加节点
        for (String vertex :
                VertexValue) {
            graph.insertVertex(vertex);
        }

        //添加边
        //A-B A-C B-C B-D B-E
//        graph.insertEdge(0,1,1); //A-B
//        graph.insertEdge(0,2,1); //A-C
//        graph.insertEdge(1,2,1); //B-C
//        graph.insertEdge(1,3,1); //B-D
//        graph.insertEdge(1,4,1); //B-E

        //更新边的关系
        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();

        //测试一下dfs 是否ok
        System.out.println("深度优先遍历：");
        graph.dfs();// A->B->C->D->E      [1->2->4->8->5->3->6->7]
        System.out.println();

        System.out.println("广度优先遍历：");
        graph.bfs();// A->B->C->D->E        [1->2->3->4->5->6->7->8]
    }

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

    //得到目标节点的第一个邻接节点的下标
    /**
     *
     * @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;
    }
    //根据前一个邻接节点的下标来获取下一个邻接节点
    /**
     *
     * @param v1 指的是一个节点的下标
     * @param v2 指的是该节点的邻接节点
     * @return  我们要找的 即是 该节点的邻接节点的下一个邻接节点的下标
     */
    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;
    }

    //深度优先遍历算法（dfs）
    // i  第一次就是 0
    private void dfs(boolean[] isVisited, int i){
        //首先我们访问该节点， 输出
        System.out.print(getValueByIndex(i)+"->");
        //将节点设置为已访问
        isVisited[i] = true;
        //查找邻接节点i的 第一个 邻接节点w
        int w = getFirstNeighbor(i);
        while (w != -1){// 说明 i 有邻接节点
            if (!isVisited[w]) {
                dfs(isVisited, w);
            }else {
                //如果w已经被访问过了
                w = getNextNeighbor(i,w);
            }
        }
    }

    //对dfs进行一个重载， 遍历我们所有的节点， 并进行dfs
    public void dfs(){
        isVisited = new boolean[getNumOfVertex()];
        //遍历所有的节点， 进行dfs【回溯】
        for (int i = 0; i < getNumOfVertex(); i++) {
            if (!isVisited[i]){
                dfs(isVisited,i);
            }
        }
    }

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

        while (! queue.isEmpty()){
            //取出队列的头结点的下标
            u = (Integer)queue.removeFirst();
            //得到第一个邻接节点的下标w
            w = getFirstNeighbor(u);
            //注： 在这个while循环里， 我们将完成对（以A节点为例）目标节点的所有邻接节点的访问
            while (w != -1){ //找到
                //是否访问过
                if (!isVisited[w]){
                    System.out.print(getValueByIndex(w)+"=>");
                    //标记为已访问
                    isVisited[w] = true;
                    //入队
                    queue.addLast(w);
                }else {
                    //寻找u节点除了w节点以外的别的邻接节点
                    // （若u以 A 的下标0为例， 则第一轮循环执行这条语句之前的的w就是 1（B），执行之后就是 2（C））
                    w = getNextNeighbor(u,w);
                }
            }
        }
    }

    //对bfs进行一个重载， 遍历我们所有的节点， 都进行bfs
    public void bfs(){
        isVisited = new boolean[getNumOfVertex()];
        for (int i = 0; i < getNumOfVertex(); i++) {
            if (!isVisited[i]){
                bfs(isVisited,i);
            }
        }
    }

    //图中常用的方法
    //显示图对应的邻接矩阵
    public void showGraph(){
        for (int[] link :
                edges) {
            System.out.println(Arrays.toString(link));
        }
    }
    //得到边的数目
    public int getNumOfEdges(){
        return numOfEdges;
    }
    //返回节点的个数
    public int getNumOfVertex(){
        return vertexList.size();
    }
    //返回节点i（下标） 对应的数据 0 -> "A" 1 -> "B" 2 -> "C"
    public String getValueByIndex(int i){
        return vertexList.get(i);
    }
    //返回v1 和 v2 的权值
    public int getWeight(int v1,int v2){
        return edges[v1][v2];
    }
    //插入节点
    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, 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]
深度优先遍历：
1->2->4->8->5->3->6->7->
广度优先遍历：
1=>2=>3=>4=>5=>6=>7=>8=>

图的深度优先 VS 广度优先

在这里插入图片描述

是渣渣呀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图形学笔记
Trouble_provider的博客
04-03 449
1.对自由度的理解： 之前以为对于一个向量来说，如果是一个三维度向量，那么就是一个三自由度的，然而，这种认识还是太浅了。自由度的严格意义，应该是指相互独立、互相不可替代的维度种类数。例如在三维笛卡尔坐标系中，三维坐标就是三个自由度，因为的变化是不可以用的变化替代的。刚体的旋转和平移，也是两个自由度，因为再怎么旋也不能变成平移。 2.旋转平移矩阵： , 其中左上角的矩阵为旋转部...
graph笔记
zsf2951186806的博客
06-02 240
Jumping Knowledge Networks 论文：Representation Learning on Graphs with Jumping Knowledge Networks 1、传统GCN在不同阶数上会有不同表现 随着阶数增加，所获取的信息更加全面，也就可以解释为啥大部分论文的GCN的层数只有2层，而之后提出的randomwalk的cotraining也依旧会导致这个问...
30.图
weixin_43719015的博客
03-11 244
问题：为什么要有图？ 前面我们学了线性表(一对一)和树(一对多) 线性表局限于一个直接前驱和一个直接后继的关系 树也只能有一个直接前驱也就是父节点 当我们需要 表示多对多的关系时， 这里我们就用到了 图 图的举例说明： 图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。 结点也可以称为顶点。如图： 图的常用概念 顶点(verte...
Java数据结构-图
qq_51938362的博客
10-16 2709
Java图
【数据结构Java】--图、BFS、DFS、拓扑结构
m0_63077733的博客
04-10 1537
有向边起点的活动称为终点的前驱活动只有当一个活动的前驱全部都完成后，这个活动才能进行有向边终点的活动称为起点的后继活动。
数据结构--图总结（八大算法）
qq_41409979的博客
05-12 2327
图总结 本章主要讲诉一些图的经典算法以及容易忘记的概念便于以后进行复习。 文章目录图总结一、易混淆的概念二、经典算法1.DFS与BFS2.读入数据总结 一、易混淆的概念 边，弧：顶点到顶点之间有向叫做边，无向叫做弧。 完全图,连通图：任意两个顶点之间都有边是完全图，任意两个顶点之间存在路劲是连通图（如果是有向的话叫强连通图）。 生成树,有向树,生成深林：无向联通图中如果只有n个顶点n-1条边（没有环）叫生成树，有向图中只有一个顶点入度为0，其余顶点入度为1叫做有向树。一个有向图由若干个有向树构成生成深林
图结构-图的数据表示法(java)
SP_1024的博客
05-22 749
思路：图有点和线组成，线上又可以有权重，那我们先把线定义出来，在定义出点，最后把线和点组成一张图，这种结构会比较清晰，比邻接矩阵法之类的更好理解。1.先定义出线段/*** 线/*** 线的权重/*** 这个是点的结构 先理解为头节点/*** 理解为尾节点或者出节点。} }2.定义出点信息/*** 点的数据结构//出度 public int out;//入度 public int in;
图片笔记.docx
12-26
很抱歉，由于您提供的信息不足，我无法生成与"图片笔记.docx"相关的详细IT知识点。标题和描述中没有提供具体的技术主题，标签也为空，且部分内容区域显示为不可读的字符。通常，图片笔记可能涉及到图像处理、图形...
流程图笔记软件.pdf
11-16
流程图笔记软件.pdf
AllPurposeNotes:一个移动应用程序，可让您记下重要笔记（文本笔记，图片笔记，语音笔记等），并以平滑的滑动轮播形式表示。 包括Firebase的出色实现
05-13
【标题】中的“AllPurposeNotes”是一个移动应用，它的核心功能是提供多类型的笔记记录功能，包括文本笔记、图片笔记和语音笔记。这种多样化的方式使用户可以方便地以最适合自己的方式记录信息。此外，该应用引入了...
js实现图片轮播效果学习笔记
10-19
主要为大家详细介绍了js实现图片轮播效果的学习笔记，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java 与数据结构（6）：图
暗星涌动
05-17 827
图是一种非常重要的数据结构，在计算机科学和网络科学中被广泛应用。图由节点（顶点）和边组成，节点表示实体，边表示实体之间的关系。图可以用来描述各种复杂的关系，如社交网络、路线图、组织结构等。在计算机科学中，图被广泛应用于图算法、网络分析、图形数据库等领域。在网络科学中，图被用于描述社交网络、互联网拓扑结构、蛋白质相互作用网络等。图可以分为有向图和无向图两种类型。有向图中的边有方向，表示从一个节点到另一个节点的单向关系。无向图中的边没有方向，表示两个节点之间的双向关系。
数据结构算法--图详解
最新发布
jy18817386398的博客
01-15 1095
图G由顶点集合V和边集合E组成，记为。：有向图和无向图。，如果，则G’为G的子图。：n(n - 1)条边的有向图。：n(n - 1) / 2条边的无向图。：图的每条边带有权值。：无向图，一条边的两点互为邻接点。：顶点v到顶点v'的边的权值和为路径长度。：无向图G，如果顶点v到顶点v'存在路径，则两顶点连通。G是一个连通图， G中的极大连通子图为连通分量。：有向图G，如果顶点v到顶点v'存在路径，则两顶点强连通。强连通图只有一个连通分量。
Java数据结构—图（Graph）
Rxq_Future的博客
04-16 1409
数据结构—图
【数据结构与算法】图(Graph)【详解】
DreamSun的博客
03-25 7346
图(Graph)是由顶点的有穷非空集合V ( G ) 和顶点之间边的集合E ( G )组成，通常表示为: G = ( V , E ) ，其中，G表示个图，V 是图G中顶点的集合，E是图G中边的集合。若V = { v 1 , v 2 , . . . , v n } ，则用∣ V ∣表示图G中顶点的个数，也称图G的阶，E = { ( u , v ) ∣ u ∈ V , v ∈ V } ，用∣ E ∣表示图G中边的条数。注意:线性表可以是空表，树可以是空树，但图不可以是空图。
字符串翻转之谜
Time flys
05-27 1818
做内容安全审查时，发现了一个奇怪的case。 明明用户的评论中含有敏感词，但是用关键词匹配却无法匹配成功。就好像like这个匹配方法失效了一样。 sql select '一个敏感词啊' like '%敏感词%' -- 结果竟然为false 用肉眼是无法看出问题的，把评论以文件形式下载到本地，用vim打开，才发现，原来文本的顺序是错乱的！见下图 以这一段文本为例，<202d><202e>耳木<202c><202c>品质差别<202d><202e
图的常用算法思路及实现（c语言）
astudybear的博客
07-26 1486
③以防图出现非连通图，所以需要写一个BFSTraverse方法循环的查看visited数组是否还有未访问的结点，有的话将该节点继续调用BFS，直至全部结点都被访问。②然后for循环找他的邻接结点，并且将他的结点都调用DFS算法，这样递归调用就会使其一直访问下去，直到它最深的结点然后回溯回去。②然后判断队列是否空，不为空就取出第一个数据，然后将其相邻结点依次访问并放入队列中，且标记已访问。①访问第一个结点v，然后将visited数组标记为已访问并且将其放入队列中。弗洛伊德算法（Floyed）.........
数据结构--图(Java版)
热门推荐
hoaven的博客
05-02 2万+
一、图的基本概念 线性表和树两类数据结构，线性表中的元素是“一对一”的关系，树中的元素是“一对多”的关系，本章所述的图结构中的元素则是“多对多”的关系。 图（Graph）是一种复杂的非线性结构，在图结构中，每个元素都可以有零个或多个前驱，也可以有零个或多个后继，也就是说，元素之间的关系是任意的。 无向图： 无向图是由顶点和边构成。 有向图： 有向图是由顶点和有...
Java数据结构之图
qq_64580912的博客
11-21 1961
1)我们学了线性表和树2)线性表局限于一个直接前驱和一个直接后继的关系3)树也只能有一个直接前驱也就是父节点4)当我们需要表示的关系时，这里我们就用到了图图是一种数据结构，其中结点可以具有零个或多个相邻元素。两个结点之间的连接称为边。结点也可以称为顶点。
matplotlib绘图笔记
09-12
Matplotlib是Python的绘图库，它提供了各种功能，可以用于绘制不同类型的图形，包括线图、散点图、等高线图、条形图、柱状图、3D图形等等。 它可以让使用者轻松地将数据图形化，并且支持多种输出格式。 要在Jupyter...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值