数据结构之图概念以及深度和广度优先搜索

已于 2022-05-13 15:11:23 修改
阅读量843 收藏 7
点赞数 1
分类专栏： 2022 # 算法 文章标签： 数据结构 算法 java
于 2022-05-11 17:15:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44289860/article/details/124690484
版权
2022 同时被 2 个专栏收录
67 篇文章 2 订阅
订阅专栏
算法
12 篇文章 0 订阅
订阅专栏

1. 图（Graph）相关概念

数据结构图示

1.1 基础概念

图由**顶点(vertex)和边(edge)**组成，通常表示为G = (V,E)。
其中：G表示一个图，V是顶点集，E是边集。
V有穷且非空。
任意两个顶点之间都可以用边来表示它们之间的关系，E可以是空的。

在这里插入图片描述

1.2 有向图（Directed Graph）

边是有明确方向的。

在这里插入图片描述

  • 有向无环图（Directed Acyclic Graph，简称 DAG）
    如果一个有向图，从任意顶点出发无法经过若干条边回到改顶点，就是一个有向无环图。

在这里插入图片描述

  • 出度、入度
  1. 出度（Out-degree）：一个顶点的出度为x，是指由x条边以该顶点为起点。

在这里插入图片描述
2. 入度（In-degree）：一个顶点的入度为x，是指由x条边以该顶点为终点。
在这里插入图片描述

1.3 无向图（Undirected Graph）

无向图的边是无方向的。

在这里插入图片描述

1.4 混合图（Mixed Graph）

混合图的边可能是无向的，也可能是有向的。

在这里插入图片描述

1.5 简单图、多重图

  • 平行边：
  1. 无向图中，关联一对顶点的无向边如果多于一条，则称这些边为平行边；
  2. 有向图中，关联一对顶点的有向边多余一条且方向相同，则这些边为平行边。
  • 多重图（Multigraph）
    有平行边或者有自环的图。在这里插入图片描述
  • 简单图（Simple Graph）
    既没有平行边也没有自环的图。

1.6 无向完全图（Directed Complete Graph）

无向图的任意两个顶点之间都存在边。n个顶点的无向完全图有n(n-1) / 2条边。

在这里插入图片描述

1.7 无向完全图（Undirected Complete Graph）

任意两点之间都存在方向相反的两条边。n个顶点的有向完全图有n(n-1)条边。

在这里插入图片描述

1.8 稠密图和稀疏图

  • 稠密图：边的数量接近于或等于完全图。
  • 稀疏图：边的数量远远小于完全图。

1.9 有权图（Weighted Graph）

有权图的边拥有权值。

在这里插入图片描述

1.10 连通图（Connected Graph）

如果顶点x和y之间存在可互相抵达的路径（直接或者间接），则称x和y是连通的。
如果无向图种任意两个顶点都是连通的，则称为连通图。

在这里插入图片描述

  • 连通分量（Connected Component）：无向图的极大连通子图。连通图只有一个连通分量，即它本身。非连通的无向图有多个连通分量。
    如：下图中有三个连通分量。

在这里插入图片描述

1.11 强连通图（Strongly Connected Graph）

有向图中任意两个顶点都是连通的，称为强连通图。

在这里插入图片描述

  • 强连通分量（Strongly Connected Component）：有向图的极大强连通子图。连通图只有一个连通分量，即它本身。非连通的有向图有多个强连通分量。
    如：下图中有三强个连通分量。

在这里插入图片描述

1.12 邻接矩阵（Adjacency Matrix）实现图的存储

  • 存储方式：
  1. 一维数组存放顶点信息；
  2. 二维数组存放边信息。
  • 无向图：二维数组中两个顶点有边用1表示，否则用0来表示。

在这里插入图片描述

  • 有向图：二维数组中节点有出度到另一节点的边用1表示，否则用0来表示。
    在这里插入图片描述- 有权图：二维数组存节点有出度到另一节点的边用权值的值表示，否则用∞来表示。
    在这里插入图片描述

  • 适合稠密图使用。

1.13 邻接表（Adjacency List）实现图的存储

  • 存储方式：
  1. 一维数组存放顶点信息；
  2. 顶点作为链表的头节点，后面指向直接可达的顶点。
  • 无向图：在链表后面存储当前顶点可以直接通往的顶点。
    在这里插入图片描述
  • 有向图：在链表后面存储当前顶点作为出度直接可达的顶点。
    在这里插入图片描述
  • 逆邻接表：在链表后面存储当前顶点作为入度直接可达的顶点。
    在这里插入图片描述
  • 有权图：在链表后面存储当前顶点作为出度直接可达的顶点，并在顶点的节点类中存储权值。
    在这里插入图片描述

2. 图的实现

2.1 接口设计

/**
 * @Description 图接口
 * @date 2022/5/10 20:31
 */
public interface Graph<V,E>{

    /**
     * 获取边的数量
     * @return 边数量
     */
    int edgeSize();

    /**
     * 获取顶点数量
     * @return 顶点数量
     */
    int verticesSize();

    /**
     * 添加一个顶点
     * @param v 顶点
     */
    void addVertex(V v);

    /**
     * 两个顶点之间添加一个边
     * @param from 起点
     * @param to 终点
     */
    void addEdge(V from, V to);

    /**
     * 两个顶点之间添加一个携带权值的边
     * @param from 起点
     * @param to 终点
     * @param weight 权值
     */
    void addEdge(V from, V to, E weight);

    /**
     * 删除一个顶点
     * @param v 顶点
     */
    void removeVertex(V v);

    /**
     * 删除一条边
     * @param from 起点
     * @param to 终点
     */
    void removeEdge(V from, V to);
    
    /**
     * 广度优先搜索
     * @param v
     */
    public abstract void bfs(V v, VertexVisitor<V> visitor);

    /**
     * 深度优先搜索
     * @param v
     */
    public abstract void dfs(V v, VertexVisitor<V> visitor);

    /**
     * 使用栈实现深度优先搜索
     * @param v
     */
    public abstract void difOfStack(V v, VertexVisitor<V> visitor);

    /**
     * dfs 和 bfs 遍历是外部获取值
     * @param <V>
     */
    public interface VertexVisitor<V> {
        boolean visit(V v);
    }
}

2.2 HashMap + HashSet实现图

  • 节点类设计：
    /**
     * 顶点类
     * @param <V>
     * @param <E>
     */
    private static class Vertex<V,E>{
        // 顶点值
        V v;
        // 以该顶点为终点的边 入度
        Set<Edge<V, E>> inEdges = new HashSet<>();
        // 以该顶点为起点的边 出度
        Set<Edge<V, E>> outEdges = new HashSet<>();

        public Vertex(V v) {
            this.v = v;
        }

        @Override
        public boolean equals(Object o) {
            // 顶点值相等就表示顶点相等
            return Objects.equals(v, ((Vertex<V,E>) o).v) ;
        }

        @Override
        public int hashCode() {
            return Objects.hash(v);
        }
    }

    /**
     * 边类
     * @param <V>
     * @param <E>
     */
    private static class Edge<V,E>{
        // 起点顶点
        Vertex<V, E> from;
        // 终点顶点
        Vertex<V, E> to;
        // 权值
        E weight;

        @Override
        public boolean equals(Object o) {
            // 起点终点相同就是同一条边
            return Objects.equals(from, ((Edge<V,E>) o).from) &&  Objects.equals(to, ((Edge<V,E>) o).to);
        }

        @Override
        public int hashCode() {
            return Objects.hash(from, to);
        }
    }
  • 全局变量
    // 存放顶点及它对应的顶点信息
    private Map<V, Vertex<V, E>> vertices = new HashMap<>();

    // 存放边信息
    private Set<Edge<V, E>> edges = new HashSet<>();
  • 边的数量 和 顶点数量
    @Override
    public int edgeSize() {
        return edges.size();
    }

    @Override
    public int verticesSize() {
        return vertices.size();
    }
  • 添加顶点
    @Override
    public void addVertex(V v) {
        if (vertices.containsKey(v)) return;
        vertices.put(v,new Vertex<>(v));
    }
  • 添加边
    @Override
    public void addEdge(V from, V to) {
        addEdge(from, to ,null);
    }

    @Override
    public void addEdge(V from, V to, E weight) {
        // 判断当前顶点是否存在
        Vertex<V, E> fromVertex = vertices.get(from);
        if (fromVertex == null){
            fromVertex = new Vertex<>(from);
            vertices.put(from,fromVertex);
        }

        Vertex<V, E> toVertex = vertices.get(to);
        if (toVertex == null){
            toVertex = new Vertex<>(to);
            vertices.put(to,toVertex);
        }

        // 新建一个边
        Edge<V, E> edge = new Edge<>(fromVertex, toVertex, weight);

        // 删除原有的边（没有就删除不了）
        if (fromVertex.outEdges.remove(edge)) {
            toVertex.inEdges.remove(edge);
            edges.remove(edge);
        }

        // 当前边是
        //  1. 起点fromVertex 的出度
        //  2. 终点toVertex 的入度
        fromVertex.outEdges.add(edge);
        toVertex.inEdges.add(edge);
        edges.add(edge);
        fromVertex.outEdges.add(edge);
        toVertex.inEdges.add(edge);
        edges.add(edge);
    }
  • 删除边
    @Override
    public void removeEdge(V from, V to) {
        // 判断顶点是否存在
        Vertex<V, E> fromVertex = vertices.get(from);
        if (fromVertex == null) return;

        Vertex<V, E> toVertex = vertices.get(to);
        if (toVertex == null) return;

        // 构建一条基于当前值的边
        Edge<V, E> edge = new Edge<>(fromVertex,toVertex);

        if (fromVertex.outEdges.remove(edge)) {
            fromVertex.inEdges.remove(edge);
            edges.remove(edge);
        }
    }
  • 删除顶点
    @Override
    public void removeVertex(V v) {
        // 直接从 map 中删除如果为空就表示不存在不需要再进行操作。
        Vertex<V, E> vertex = vertices.remove(v);
        if (vertex == null) return;

        // 删除当前顶点时 还需要删除当前顶点作为 起点 和 终点 的边。

        // 当前节点的作为出度的迭代器
        Iterator<Edge<V, E>> outIterator = vertex.outEdges.iterator();
        while (outIterator.hasNext()) {
            // 获取作为当前顶点作为起点的边
            Edge<V, E> edge = outIterator.next();
            // 从边的视角来说作为 出度 即就是终点的入度
            edge.to.inEdges.remove(edge);
            // 迭代器中删除-从集合中删除
            outIterator.remove();
            // 边集合中删除
            edges.remove(edge);
        }

        // 当前节点的作为入度的迭代器
        Iterator<Edge<V, E>> inIterator = vertex.inEdges.iterator();
        while (inIterator.hasNext()) {
            // 获取作为当前顶点作为终点的边
            Edge<V, E> edge = inIterator.next();
            // 从边的视角来说作为 入度 即就是起点的出度
            edge.from.outEdges.remove(edge);
            // 迭代器中删除-从集合中删除
            inIterator.remove();
            // 边集合中删除
            edges.remove(edge);
        }
    }

3. 广度优先搜索（Breadth First Search，简称 BFS）

又称宽度优先搜索、横向优先搜索，是一种图的遍历实现方式。
图的遍历是指从图中某一个顶点出发访问图的其余顶点，且每个顶点仅被访问一次。
二叉树的层序遍历就是一种广度优先算法。

遍历结果中的顶点没有规定的顺序。

  • 无序图的遍历：以顶点A开始，作为第一层；以顶点A直接可达的顶点B、F为第二层；依次类推G、I、C、E为第三层；H、D为第四层。
    在这里插入图片描述
  • 有序图的遍历：遍历的顺序与无序图一致，但是要遵守方向。

在这里插入图片描述

  • 实现：与二叉树的层序遍历思路完全相同，即使用一个队列将遍历得到的顶点加入到队列中；但因为需要保证每个顶点只到达一次，需要使用hashset来实现。
    @Override
    public void bfs(V v, VertexVisitor<V> visitor) {
        if (visitor == null) return;
        // 根据传入的顶点值 获取顶点
        Vertex<V, E> beginVertex = vertices.get(v);
        if (beginVertex == null) return;

        // 将遍历过的节点存入到 set 中保证只遍历一次
        Set<Vertex<V, E>> set = new HashSet<>();
        set.add(beginVertex);

        Queue<Vertex<V, E>> queue = new LinkedList<>();
        queue.offer(beginVertex);

        while (!queue.isEmpty()){
            Vertex<V, E> vertex = queue.poll();
            if (visitor.visit(vertex.v)) return;
            set.add(vertex);

            for (Edge<V,E> outEdge : vertex.outEdges) {
                if (set.contains(outEdge.to)) continue;
                queue.offer(outEdge.to);
            }
        }
    }

4. 深度度优先搜索（Depth First Search，简称 DFS）

二叉树的前序遍历其实就是深度优先搜索的一种。
其实就是从选定的一个顶点，一直往下走，直到走不动就倒退一个顶点选择其它的方向走，走不动再倒退顶点，类推…。

  • 无序图的遍历：
    在这里插入图片描述
  • 有序图的遍历：如下图中：先走蓝线，等到再次走到顶点e时，无法再进行遍历，就回退，一直回退到节点e，然后选择其它方向f。

在这里插入图片描述

  • 实现：与前序遍历思路相同，将切换到左右子节点的代码换成切换成当前顶点往外出去的线的终点的点，再附加set保证唯一即可。
    @Override
    public void dfs(V v, VertexVisitor<V> visitor) {
        if (visitor == null) return;
        Vertex<V, E> beginVertex = vertices.get(v);
        if (beginVertex == null) return;
        dfs(beginVertex, new HashSet<>(), visitor);
    }

    private void dfs(Vertex<V, E> vertex, Set<Vertex<V,E>> set, VertexVisitor<V> visitor){
        if (visitor.visit(vertex.v)) return;
        set.add(vertex);

        for (Edge<V,E> outEdge : vertex.outEdges) {
            if (set.contains(outEdge.to)) continue;
            dfs(outEdge.to, set, visitor);
        }
    }
  • 非递归方式，使用栈实现：
    在这里插入图片描述
    这里以顶点 1 作为开始顶点进行遍历。
  1. 将开始顶点入栈，并进行输出和出栈：
    入栈：
    在这里插入图片描述
    出栈：
    在这里插入图片描述
  2. 根据当前栈顶的顶点元素获取一条边，将改边的起点和终点按顺序加入到栈中，然后输出栈顶顶点；break退出循环保证只访问一条边。
    这里选择1，3这条边。
    入栈：
    在这里插入图片描述
  3. 弹出栈顶元素，再选择一条边，将起点和终点按照顺序加入到栈中，打印此时的栈顶元素。
    弹出栈顶元素：
    在这里插入图片描述
    入栈起点和终点：
    在这里插入图片描述
  4. 此时顶点7并没有其它的边可以遍历，只能弹出再弹出，直到弹出到顶点1时才能够选择其它的边，再进行入栈操作。
    @Override
    public void difOfStack(V v, VertexVisitor<V> visitor) {
        Vertex<V, E> beginVertex = vertices.get(v);
        if (beginVertex == null) return;

        Set<Vertex<V, E>> set = new HashSet<>();
        Stack<Vertex<V ,E>> stack = new Stack<>();

        // 访问起点
        stack.push(beginVertex);
        set.add(beginVertex);
        if (visitor.visit(beginVertex.v)) return;

        while (!stack.isEmpty()){
            Vertex<V, E> vertex = stack.pop();
            // 遍历当前节点作为起点的边
            for (Edge<V, E> edge : vertex.outEdges) {
                // 访问过就跳过
                if (set.contains(edge.to)) continue;

                // 起点和终点都入栈
                stack.push(edge.from);
                stack.push(edge.to);

                // 加入到set
                set.add(edge.to);
                if (visitor.visit(edge.to.v)) return;
                break;
            }
        }
    }
江海i
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之图的广度优先搜索
bbewx的专栏
05-11 2005
遍历原则： 从图中指定的
【数据结构】——图的深度优先搜索和广度优先搜索
atwdy的博客
07-29 5029
关于邻接矩阵和邻接表：https://blog.csdn.net/namewdy/article/details/105668761 下面都以此图进行遍历： 1.深度优先搜索 深度优先搜索，Depth First Search，简称DFS。 对于一个连通图，深度优先遍历的过程： 从图中一个顶点 vvv 出发并访问 vvv 。 找到刚访问顶点的第一个未被访问的邻接点并访问，并继续以该邻接点作为刚访问过的顶点，重复此步骤直到刚访问过的结点没有未被访问的邻接点为止。 返回上一个访问过的且还有未被访问邻接.
[数据结构]图的深度优先搜索（DFS）和广度优先搜索（BFS）（通俗易懂）
IT博客-wusheng_z
04-15 573
一、深度优先搜索（DFS，Depth First Search） 深度优先搜索的主要思想：首先从一个未走过的顶点作为起始顶点，沿当前顶点的边走到未访问过的顶点；当没有被访问过的顶点时，则回到上一个顶点，继续访问别的未被访问过的顶点，直到所有的顶点都被访问过。（不撞南墙不回头） DFS遍历图解过程如下： 1、DFS邻接矩阵核心代码实现（可以链表实现，以下是数组实现）： bool boo...
数据结构—图的广度优先搜索
Miss Z的博客
09-11 1448
图的存储及基本操作
【数据结构】图的广度优先搜索
weixin_30765319的博客
08-29 78
　　图的广度优先搜索（BFS）与树的广度优先搜索类似。与树不同的是，图中可能存在循环。所我们可能会再次访问到同一个节点。为了表面多次处理同一个节点，我们要布尔变量数据记录节点有没有被访问过。为了简化，我们假设所有的节点都是从根节点可达的。 　　比如在下图中，我们从节点2出发。当我们访问到节点0时，我们寻找所有与他相邻的节点。节点2就是与0相邻的节点，如果我们不对已访问的节点做标记，那么节点2就会...
数据结构与算法系列21--深度和广度优先搜索
Lin的博客
12-26 360
图
深度优先搜索和广度优先搜索（数据结构）
ker的博客
02-19 3072
图的两种遍历方式基本概念深度优先搜索邻接矩阵表示图的深度优先搜索遍历广度优先搜索 基本概念 图的遍历定义： 从已给的连通图中某一顶点出发，沿着一些边访遍图中所有的顶点，且使每个顶点仅被访问一次，就叫做图的遍历，它是图的基本运算。 遍历实质：找每个顶点的邻接点的过程。 图的特点: 图中可能存在回路，且图的任一顶点都可能与其它顶点想通，在访问完某个顶点之后可能会沿着某些边又回到了曾经访问过的顶点...
【数据结构】图的遍历--广度优先搜索
萧十一的技术小站
04-21 889
广度优先搜索过程类似于树的层次遍历，假设从图中某顶点i出发，在访问i之后依次访问i的各个未被访问的邻接点，然后从这些邻接点出发依次访问他们的邻接点，并使“先被访问的顶点的邻接点”先于“后被访问的顶点的邻接点”被访问，直到所有顶点都被访问到（限于连通图）。如果是非连通图，则从未被访问的顶点中任选一个，再次重复上述过程。 换句话说，广度优先搜索过程中其实是以顶点i为起始点，由近及远，依次访问了与i路径
数据结构之图的广度、深度优先搜索
小情绪 Triste *
10-12 291
数据结构：图的遍历 1.图的搜索方式分为两种： 深度优先搜索(dfs)： 类似于树的先根遍历，每次访问完当前结点后首先访问当前结点的第一个 邻接点，是一个递归的过程 广度优先搜索(bfs)： 类似于树的按层次遍历，每次访问完当前结点后继续访问当前结点的所有 邻接点，通常与队列配合使用 2.注意事项： 因 图结构 结点间的关系是多对多的，所以可能存在 回路，所以在遍历时需要 用数组visited[]记录所访问过的结点，防出现死循环 3.图的遍历(邻接矩阵存储)
数据结构之广度优先搜索
所幸你是例外的博客
04-06 597
广度优先搜索呈现出一层一层向外扩张的特点，先看到的结点先遍历，后看到的结点后遍历，因此广度优先搜索可以借助**队列**实现。当遍历到一个结点时，若这个结点有左（右）孩子结点，依次入队即可。结合队列实现思路如下图所示： BFS模板代码 int BFS(Node root, Node target){ Queue<Node> queue = new ArrayDeque<>(); int step = 0; //添加根节点到队列 queue.add(ro
数据结构图的建立与深度和广度遍历代码
12-31
#include #include #include using namespace std; #define MAX_VERTEX_NUM 20//最大顶点数 #define MaxSize 400 typedef int QueueElementType;
数据结构与算法 ---- 图的广度优先搜索（BFS）和深度优先搜索（DFS）
qq_41877840的博客
08-11 780
1.前言 和树的遍历类似，图的遍历也是从图中某点出发，然后按照某种方法对图中所有顶点进行访问，且仅访问一次。 但是图的遍历相对树而言要更为复杂。因为图中的任意顶点都可能与其他顶点相邻，所以在图的遍历中必须记录已被访问的顶点，避免重复访问。 根据搜索路径的不同，我们可以将遍历图的方法分为两种：广度优先搜索和深度优先搜索。 2.图的基本概念 2.1.无向图和无向图 顶点对(u，v)是无序的，即（u，v）和（v，u）是同一条边。常用一对圆括号表示。 顶点对<u,v>是有序的，它是指从顶点u到顶点 v
408数据结构学习笔记——图的广度优先搜索、深度优先搜索
JiangNan_1002的博客
04-09 1909
1.广度优先搜索 2.深度优先搜索 3.图的遍历和图的连通性 4.王道课后题
数据结构：深度优先与广度优先
dgeek的博客
05-24 784
深度优先package graph;import java.util.Stack;/* * 使用深度优先搜索查找图中的路径 */ public class DepthFirstPaths { private boolean[] marked; //是否以被标记 private int[] edgeTo; //从起点到一个顶点的已知路径上的最后一个顶点 private fi
数据结构算法系列----广度优先搜索（bfs）
最新发布
2301_77961281的博客
04-03 1641
BFS（广度优先搜索）是一种图搜索算法，用于在图或树数据结构中进行遍历。BFS从根节点开始，沿着图的宽度遍历图的顶点，直到找到目标顶点或遍历完所有顶点。在BFS中，首先访问根节点，然后依次访问与根节点相邻的节点，再依次访问这些相邻节点的邻居节点，以此类推。BFS通常使用队列数据结构来实现。BFS的基本思想是将当前节点的所有邻居节点都加入到队列中，然后逐个访问队列中的节点，并将它们的邻居节点加入队列。这样可以保证先访问距离当前节点较近的节点，从而实现按层级遍历。在计算机科学中，BFS常用于解决图的。
【数据结构与算法】图的深度与广度遍历
A2BGeek的专栏
08-25 1526
图的深度遍历与广度遍历与二叉树的遍历类似，但是因为是图，需要有个数组存一下点是否被遍历过。 代码实现 /** * 源码名称：GraphIterateMatrix.java * 日期：2014-08-25 * 程序功能：图的深度与广度遍历 * 版权：CopyRight@A2BGeek * 作者：A2BGeek */ import java.util.LinkedList;
【自己动手写数据结构】 -- 图的广度优先搜索算法
"程序猿“的专栏
04-12 1633
/* * 基于邻接矩阵存储的图的广度优先搜索算法（BFS） */ #include #include typedef int Bool; #define FALSE 0 #define TRUE 1 //定义顶点类型 typedef char VertexType; //定义边上权值类型 typedef int EdgeType; //定义图中顶点数目的最大值 #define MAXV
数据结构——图（2），深度优先搜索和广度优先搜索
wayblink的博客
03-30 1297
沿袭上一篇文章的图存储结构，因为知道有向图和无向图的存储结构相同，只不过数据不同，可以理解为无向图是一种方向必须成对存在的有向图，因此，遍历方法实际上是可以通用的，分为邻接矩阵遍历和邻接表遍历。深度优先搜索图的深度优先搜索(Depth First Search)，和树的先序遍历比较类似。它的思想：假设初始状态是图中所有顶点均未被访问，则从某个顶点v出发，首先访问该顶点，然后依次从它的各个未被访问的邻
10、【数据结构】图之深度优先和广度优先搜索
阿牧路泽
10-31 1164
一、深度优先搜索 1、深度优先搜索介绍 2、无向图的深度优先搜索 3、有向图的深度优先搜索 二、广度优先搜索 1、广度优先搜索介绍 2、无向图的广度优先搜索 3、有向图的广度优先搜索 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值