dhu 图 邻接表ADT实现

已于 2022-09-27 22:04:39 修改
阅读量139 收藏 2
点赞数
分类专栏： c++ dhu 知识点总结 文章标签： 深度优先 图论 c++
于 2022-07-24 01:16:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_60462402/article/details/125955065
版权
dhu 同时被 3 个专栏收录
32 篇文章 21 订阅
订阅专栏
c++
28 篇文章 5 订阅
订阅专栏
知识点总结
6 篇文章 0 订阅
订阅专栏

目的：使用C++模板设计并逐步完善图的邻接矩阵抽象数据类型（ADT）。

内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接矩阵ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。）

（2）使用构造函数，构造一个具有结点和边的有权图。

注意：DG（有向图）, DN（有向网）, UDG（无向图）, UDN（无向网）

题解

不了解接口怎么写的可以参考我另一篇邻接矩阵ADT的博客

/* 边表的结点定义 */
template<class TypeOfEdge>
struct edgeNode
{
    int data;
    TypeOfEdge weight;
    edgeNode<TypeOfEdge>* next;
    edgeNode(const int& d, edgeNode<TypeOfEdge>* ptr = NULL) //构造函数，用于构造其他结点（无权图） 
    //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面
    {
        next = ptr;
        data = d;
        weight = 0;
    }
    edgeNode(const int& d, const TypeOfEdge& w, edgeNode<TypeOfEdge>* ptr = NULL) //构造函数，用于构造其他结点（带权图） 
    //函数参数表中的形参允许有默认值，但是带默认值的参数需要放后面
    {
        next = ptr;
        data = d;
        weight = w;
    }
    int getData() { return data; }  //取得结点的序号（顶点集） 
    TypeOfEdge getWeight() { return weight; }  //取得边集中对应边的权值 
    void SetLink(edgeNode<TypeOfEdge>* link) { next = link; }  //修改结点的next域 
    void SetData(int value) { data = value; }   //修改结点的序号（顶点集） 
    void SetWeight(TypeOfEdge value) { weight = value; }   //修改边集中对应边的权值   
};
//图的邻接表类
template<class TypeOfVer, class TypeOfEdge>
struct verNode
{
    TypeOfVer ver;
    edgeNode<TypeOfEdge>* head;
    verNode(edgeNode<TypeOfEdge>* h = NULL) { head = h;  }
    TypeOfVer getVer() { return ver; }  //取得结点值（顶点集） 
    edgeNode<TypeOfEdge>* getHead() { return head; }  //取得对应的边表的头指针 
    void setVer(TypeOfVer value) { ver = value; }  //设置结点值（顶点集） 
    void setHead(edgeNode<TypeOfEdge>* value) { head = value; }  //设置对应的边表的头指针
};
template <class TypeOfVer, class TypeOfEdge>
class adjlist_graph {
private:
    int Vers;           //顶点数 
    int Edges;          //边数 
    verNode<TypeOfVer, TypeOfEdge>* verList;
    string GraphKind;     //图的种类标志 
    bool Delete_Edge(int u, int v)
    {
        edgeNode <TypeOfEdge>* p = verList[u].head;
        while (p->next != NULL) {
            if (p->data == v) {
                break;
            }
            if (p->next == NULL)
                break;
            p = p->next;
        }
        edgeNode <TypeOfEdge>* q = verList[u].head;
        if (q!=p)
            while (q->next != p) {
                q = q->next;
            }
        q->next = p->next;
        delete p;
        return 1;
    }
    bool DFS(int u, int& num, int visited[]) //DFS遍历（递归部分）
    {
        int i = u;
        edgeNode <TypeOfEdge>* p = verList[i].head;
        while (p != NULL) {
            if (visited[p->data] == 0) {
                cout << "->" << verList[p->data].ver;
                visited[p->data] = 1;
                num++;
                DFS( p->data,num, visited);
            }
            if (p->next == NULL)
                break;
                p = p->next;
        }
        return 1;
    }
    bool w1;
public:
    void display()//测试用
    {
        for (int i = 0; i < Vers; i++) {
            cout << verList[i].ver;
            if (i != Vers - 1)
                cout << " ";
        }
        cout << endl;
        for (int i = 0; i < Vers; i++) {
            edgeNode <TypeOfEdge> * p = verList[i].head;
            cout << verList[i].ver << ":";
            while (p != NULL) {
                cout << p->data <<":"<<p->weight;
                if (p->next == NULL)
                    break;
                cout << "->";
                p = p->next;
            }
            if (i != Vers - 1)
                cout << endl;
        }
    }
    adjlist_graph(const string& kd, int vSize, const TypeOfVer d[])
    { //构造函数构造一个只有结点没有边的图。
        GraphKind = kd; Vers = vSize; w1 = 0;
        verList=new verNode<TypeOfVer,TypeOfEdge> [Vers];
            for(int i=0;i<Vers;++i)
                verList[i].ver=d[i];
    }
    adjlist_graph(const string& kd, int vSize, int eSize, const TypeOfVer d[], int** e)
    { //构造函数构造一个无权图。5个参数的含义：图的类型、结点数、边数、结点集和边集 
        GraphKind = kd; Vers = vSize; w1 = 0;
        verList = new verNode<TypeOfVer, TypeOfEdge>[Vers];
        for (int i = 0; i < Vers; ++i)
            verList[i].ver = d[i];
        Edges = eSize;
        for (int i = 0; i < eSize; i++) {
            edgeNode<TypeOfEdge> *p = new edgeNode<TypeOfEdge>(e[i][1]);
            if ( kd == "DG") {
                p->next = verList[e[i][0]].head;
                verList[e[i][0]].head = p;
            }
            else {
                p->next = verList[e[i][0]].head;
                verList[e[i][0]].head = p;
                edgeNode<TypeOfEdge>*q = new edgeNode<TypeOfEdge>( e[i][0]);
                q->next = verList[e[i][1]].head;
                verList[e[i][1]].head = q;
            }
        }
    }
    adjlist_graph(const string& kd, int vSize, int eSize, const TypeOfVer d[], int** e, const TypeOfEdge w[]) //构造函数构造一个有权图。
    {
        GraphKind = kd; Vers = vSize; w1 = 1;
        verList = new verNode<TypeOfVer, TypeOfEdge>[Vers];
        for (int i = 0; i < Vers; ++i)
            verList[i].ver = d[i];
        Edges = eSize;
        for (int i = 0; i < eSize; i++) {
            edgeNode<TypeOfEdge>* p = new edgeNode<TypeOfEdge>(e[i][1]);
            p->weight = w[i];
            if (kd == "DN") {
                p->next = verList[e[i][0]].head;
                verList[e[i][0]].head = p;
            }
            else {
                p->next = verList[e[i][0]].head;
                verList[e[i][0]].head = p;
                edgeNode<TypeOfEdge>* q = new edgeNode<TypeOfEdge>(e[i][0]);
                q->weight = w[i];
                q->next = verList[e[i][1]].head;
                verList[e[i][1]].head = q;
            }
        }
    }
    bool GraphisEmpty() { return Vers == 0; }  //判断图空否
    string GetGraphKind() { return GraphKind; }
    bool GetVer(int u, TypeOfVer& data) //取得G中指定顶点的值 
    {
        data = verList[u].ver;
        return 1;
    }
    int GetFirstAdjVex(int u, int& v) //返回G中指定顶点u的第一个邻接顶点的位序（顶点集）。若顶点在G中没有邻接顶点，则返回-1
    {
        if (u<0 || u>Vers - 1) {
            v = -1;
            return -1;
        }
        if (verList[u].head != NULL) {
            v = verList[u].head->data;
            return 1;
        }
        v = -1;
        return -1;
    }
    int GetNextAdjVex(int u, int v, int& w) //返回G中指定顶点u的下一个邻接顶点（相对于v）的位序（顶点集）。若顶点在G中没有邻接顶点，则返回false
    {
        if (u<0 || u>Vers - 1) {
            v = -1;
            return -1;
        }
        edgeNode <TypeOfEdge>* p = verList[u].head;
        while (p != NULL) {
            if (p->data == v) {
                w = verList[u].head->data;
                return 1;
            }
            if (p->next == NULL)
                break;
            p = p->next;
        }
        w = -1;
        return -1;
    }
    bool PutVer(int u, TypeOfVer data) //对G中指定顶点赋值 
    {
        verList[u].ver = data;
        return 1;
    }
    bool InsertVer(const TypeOfVer& data) //往G中添加一个顶点 
    {
        verNode<TypeOfVer, TypeOfEdge>* verList2 = new verNode<TypeOfVer, TypeOfEdge>[Vers + 1];
        for (int i = 0; i < Vers; i++) {
            verList2[i] = verList[i];
            verList[i] = NULL;
        }
        verList2[Vers].ver = data;
        verList2[Vers].head = NULL;
        delete verList;
        verList = verList2;
        Vers++;
        return 1;
    }
    int LocateVer(TypeOfVer data) //返回G中指定顶点的位置 
    {
        for (int i = 0; i < Vers; i++) {
            if (verList[i].ver == data)
                return i;
        }
        return -1;
    }
    bool ExistEdge(int u, int v) //没写注释，我猜是判断边是否存在？
    {
        edgeNode <TypeOfEdge>* p = verList[u].head;
        while (p != NULL) {
            if (p->data == v)
                return 1;
            if (p->next == NULL)
                break;
            p = p->next;
        }
        p = verList[v].head;
        while (p != NULL) {
            if (p->data == u)
                return 1;
            if (p->next == NULL)
                break;
            p = p->next;
        }
        return 0;
    }
    bool PrintVer()  //输出顶点集 
    {
        for (int i = 0; i < Vers; i++) {
            cout << verList[i].ver;
            if (i != Vers - 1)
                cout << " ";
        }
        return 1;
    }
    bool PrintAdjList()  //输出邻接矩阵(?) 
    {
        if (w1 == 0)
            for (int i = 0; i < Vers; i++) {
                edgeNode <TypeOfEdge>* p = verList[i].head;
                cout << verList[i].ver << "->";
                while (p != NULL) {
                    cout << p->data << "->";
                    if (p->next == NULL)
                        break;
                    p = p->next;
                }
                cout << "nullptr";
                if (i != Vers - 1)
                    cout << endl;
            }
        else
            for (int i = 0; i < Vers; i++) {
                edgeNode <TypeOfEdge>* p = verList[i].head;
                cout << verList[i].ver << "->";
                while (p != NULL) {
                    cout << p->data <<"("<<p->weight<<")" << "->";
                    if (p->next == NULL)
                        break;
                    p = p->next;
                }
                cout << "nullptr";
                if (i != Vers - 1)
                    cout << endl;
            }
        return 1;
    }
    int GetVerNum() { return Vers; }    //取得当前顶点数 
    int GetEdgeNum() { return Edges; }  //取得当前边数 
    bool Insert_Edge(int u, int v) //无权图插入一条边
    {
        edgeNode <TypeOfEdge>* o = verList[u].head;
        while (o != NULL) {
            if (o->data == v)
                return 0;
            o = o->next;
        }
        if (GraphKind == "DG") {
            edgeNode <TypeOfEdge>* p = new edgeNode <TypeOfEdge>(v);
            p->next = verList[u].head;
            verList[u].head = p;
        }
        else {
            edgeNode <TypeOfEdge>* p = new edgeNode <TypeOfEdge>(v);
            p->next = verList[u].head;
            verList[u].head = p;
            edgeNode <TypeOfEdge>* q = new edgeNode <TypeOfEdge>(u);
            q->next = verList[v].head;
            verList[v].head = q;
        }
        Edges++;
        return 1;
    }
    bool Insert_Edge(int u, int v, TypeOfEdge w) //有权图插入一条边
    {
        if (GraphKind == "DG") {
            edgeNode <TypeOfEdge>* p = new edgeNode <TypeOfEdge>(v,w);
            p->next = verList[u].head;
            verList[u].head = p;
        }
        else {
            edgeNode <TypeOfEdge>* p = new edgeNode <TypeOfEdge>(v,w);
            p->next = verList[u].head;
            verList[u].head = p;
            edgeNode <TypeOfEdge>* q = new edgeNode <TypeOfEdge>(u,w);
            q->next = verList[v].head;
            verList[v].head = q;
        }
        Edges++;
        return 1;
    }
    bool DeleteVer(const TypeOfVer& data) //往G中删除一个顶点 
    {
        int u = LocateVer(data);
        verNode<TypeOfVer, TypeOfEdge>* verList2 = new verNode<TypeOfVer, TypeOfEdge>[Vers - 1];
        for (int i = 0, k = 0; i < Vers; i++) {
            if (i != u) {
                verList2[k] = verList[i];
                verList[i] = NULL;
                k++;
            }
        }
        delete verList;
        verList = verList2;
        Vers--;
        edgeNode <TypeOfEdge>* p = NULL;
        edgeNode <TypeOfEdge>* q = NULL;
        for (int i = 0; i < Vers; i++) {
            p = verList[i].head;
            if (p != NULL  && p->next == NULL) {
                if (p->data == u) {
                    verList[i].head == NULL;
                    delete p;
                }
                else if (p->data > u) {
                    p->data=p->data-1;
                }
                continue;
            }
            p = p->next;
            q = verList[i].head;
            while (p!=NULL) {
                if (p->data == u) {
                    q = p->next;
                    delete p;
                    p = q->next;
                }
                else if (p->data > u) {
                    p->data = p->data - 1;
                }
                if (p->next != NULL) {
                    p = p->next;
                    q = q->next;
                }
            }
            q = verList[i].head;
            if (q->data == u) {
                verList[i].head = q->next;
                delete q;
            }
            else if (q->data > u) {
                q->data = q->data - 1;
            }
        }
        return 1;
    }
    bool DeleteEdge(int u, int v) //删除边 (外壳：有向（删除1条边）， 无向（删除2条边））
    {
        if (GraphKind == "DN" || GraphKind == "DG")
            Delete_Edge(u,v);
        else {
            Delete_Edge(u, v);
            Delete_Edge(v, u);
        }
        return 1;
    }
    void DFS_Traverse(int u) //DFS遍历（外壳部分）
    {
        int s[1000] = { 0 };
        cout << verList[u].ver;
        s[u] = 1;
        for (int i = u; i < Vers; i++) {
            if (s[i] != 0 && i != u) {
                continue;
            }
            s[i] = 1;
            DFS(u, i, s);
        }
        for (int i = 0; i < u; i++) {
            if (s[i] != 0) {
                continue;
            }
            s[i] = 1;
            DFS(u, i, s);
        }
        cout << endl;
    }
    void BFS_Traverse(int u) //BFS遍历
    {
        int s[1000] = { 0 };
        cout << verList[u].ver;
        s[u] = 1;
        for (int i = u; i < Vers; i++) {
            edgeNode <TypeOfEdge>* p = verList[i].head;
            if (s[i] == 0) {
                cout << "->" << verList[i].ver;
                s[i] = 1;
            }
            while (p != NULL) {
                if (s[p->data] == 0) {
                    s[p->data] = 1;
                    cout << "->" << verList[p->data].ver;
                }
                p = p->next;
            }
        }
        for (int i = 0; i < u; i++) {
            edgeNode <TypeOfEdge>* p = verList[u].head;
            if (s[i] == 0) {
                cout << "->" << verList[i].ver;
                s[i] = 1;
            }
            while (p != NULL) {
                if (s[p->data] == 0) {
                    s[p->data] = 1;
                    cout << "->" << verList[p->data].ver;
                }
                p = p->next;
            }
        }
    }
    int GetDegree(int u)
    {
        if (u < 0 || u >= Vers)
            return -1;
        int num = 0;
        edgeNode <TypeOfEdge>* p = verList[u].head;
        while (p != NULL) {
            num++;
            p = p->next;
        }
        return num;
    }
    bool GetWeight(int u, int v, int& w)
    {
        edgeNode <TypeOfEdge>* p = verList[u].head;
        while (p != NULL) {
            if (p->data == v) {
                w = p->weight;
                return 1;
            }
            if (p->next == NULL)
                break;
            p = p->next;
        }
        p = verList[v].head;
        while (p != NULL) {
            if (p->data == u) {
                w = p->weight;
                return 1;
            }
            if (p->next == NULL)
                break;
            p = p->next;
        }
        return 0;
    }
};
凤凰院克里斯
关注
专栏目录
邻接表：删除一个顶点（二臂版）
xiatutut的博客
07-05 469
邻接表：删除一个顶点 时间限制: 1S类别: DS：图->邻接表 晚于: 2022-07-31 23:55:00后提交分数乘系数50% 截止日期: 2022-08-07 23:55:00 问题描述 :目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。 内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。） （2）设计并实.......
邻接矩阵：构造有权图
xiatutut的博客
06-01 935
邻接矩阵：构造有权图
【邻接表】69 邻接表：构造有权图
windyuan~
03-02 2041
问题描述 : 目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。 内容： （1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。） （2）使用构造函数，构造一个有权图。 注意：DG（有向图）, DN（有向网）, UDG（无向图）, UDN（无向网） 参考函数原型： //构造函数构造一个有权图。6个参数的含义：图的类型..
邻接表的深度优先搜索(DFS)
weixin_30273501的博客
11-29 122
#include<stdio.h> #include<stdlib.h> #define INFINITY INT_MAX #define MAX_VERTEX_NUM 20 #define OK 1 #define ERROR -1 #define TRUE 1 #define FALSE 0 typedef enum{DG , DN, UDG, UDN} G...
邻接表：删除一个顶点
nameofworld的博客
07-05 804
邻接表：删除一个顶点作者: 冯向阳时间限制: 1S章节: DS:图截止日期: 2022-06-30 23:55:00问题描述 :目的：使用C++模板设计并逐步完善图的邻接表抽象数据类型（ADT）。内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接表ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。）（2）设计并实现一个算法，在已存在的图中查找指定元素值的结点，如查找成功，则删除之（包括与之相关的边）；
邻接表删边
Salute
11-24 521
链式向前星删边
AndroidAuto-Emulator(DHU)-For-Linux
12-14
《Android Auto Emulator (DHU) for Linux：打造车载体验的新纪元》 在现代科技的快速发展中，Android Auto已经成为连接智能手机与车载信息娱乐系统的重要桥梁。为了满足开发者和用户在Linux平台上模拟Android Auto...
图的邻接矩阵：广度优先遍历
xiatutut的博客
06-02 1515
目的：使用C++模板设计并逐步完善图的邻接矩阵抽象数据类型（ADT）。内容：（1）请参照图的邻接矩阵模板类原型，设计并逐步完善图的邻接矩阵ADT。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。）（2）设计并实现一个算法，使用队列，对一个已存在的图进行广度优先遍历（BFS)，并输出遍历的顶点线性序列。遍历的起点通过输入指定。注意：遍历时，仅从该点出发遍历整个图，如果图不连通，则只遍历一个子图。图的存储结构采用邻接矩阵。将
DHU 3 删除链表第index个结点
qq_41674453的博客
07-05 369
3 删除链表第index个结点 作者: Turbo时间限制: 1S章节: 链表 问题描述 输入若干（不超过100个）非负整数，创建一个不带头结点的单向链表。在输入一个位置index，从链表中删除第index个结点,输出结果链表。 请编写deleteNode函数，完成删除操作。deleteNode函数的原型如下： struct student *deleteNode(struct student *head,int index) 形参： struct student *head：链表的头指针，需要从这个链表中
DHU 2 在链表指定位置插入结点
qq_41674453的博客
07-05 556
2 在链表指定位置插入结点 作者: Turbo时间限制: 1S章节: 链表 问题描述 输入若干（不超过100个）非负整数，创建一个不带头结点的单向链表。 再输入一个位置index以及一个数据data，程序中首先创建一个新结点s，s的数据成员为data，然后调用函数insertNode将s插入到链表的指定位置index处，最后输出结果链表。 请编写insertNode函数，完成插入操作。insertNode函数的原型如下： struct student *insertNode(struct student *
邻接表表示的图的深度优先遍历
12-18
《数据结构与算法（C++）》相关 邻接表表示的图的深度优先遍历的动画演示
C++实现邻接表顶点的删除
08-19
主要为大家详细介绍了C++实现邻接表顶点的删除，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
邻接表—深度优先遍历
wh1236666的博客
12-15 1万+
深度优先遍历和广度优先遍历的参考知识点：https://blog.csdn.net/a2217018103/article/details/90678830 下面是使用邻接表做出的深度优先遍历案例： #include<stdlib.h> #include<stdio.h> #include<malloc.h> #include<string.h> //图的邻接表类型定义 typedef char VertexType[4]; typedef char Info
邻接表的深度优先遍历
给你更好的
12-24 6924
#include&lt;iostream&gt; using namespace std; #define max 100 int i,j,m1,m2,n1,n2,w,visited[100]; typedef struct ArcNode { //边结点 int adjvex; //该边所指向的顶点位置 struct ArcNode * nextarc;...
基于邻接表的深度优先遍历
实践求真知
06-25 2736
三 测试
基于邻接表的新顶点的增加
weixin_34000916的博客
12-04 1857
基于邻接表的新顶点的增加 发布时间: 2018年11月26日 10:19 时间限制: 1000ms 内存限制: 128M 描述 给定一个无向图，在此无向图中增加一个新顶点。 输入 多组数据，每组m+2行。第一行有两个数字n和m，代表有n个顶点和m条边。顶点编号为1到n。第二行到第m+1行每行有两个数字h和k，代表边依附的两个顶点。第m+2行有一个数字f，代表新插入...
图的深度优先遍历(邻接表)
热门推荐
t_wu的博客
04-13 4万+
1.深度优先遍历        图的深度优先遍历是从图的某个顶点出发，访问这个顶点，然后从v的没访问过的邻接点出发深度优先遍历图，直到图中所有和v有路径相通的顶点都被访问到。而以上是对应连通图而言，对于非连通图，先对它的连通分量进行深度优先遍历，，若图中还有顶点未被访问，则选择图中一个未曾被访问的顶点作为起始点，重复上述过程，直到图中全部顶点被访问。假设从0开始进行未循环深度优先遍历，则顺序是这样...
勾选之后，删除对应的数据（可多选删除）
Pandora_417的博客
09-12 464
注释的部分是原始删除，通过delete接口删除。后来改需求为改状态为删除的状态，使该状态不显示即可。即为put接口改数据了。 方法逻辑： 先判断所勾选数据是否为空 获取所勾选数据的id数据 弹出确认删除的弹框 遍历循环删除 几条数据已被删除 加个setTimeout定时器来刷新页面window.location.reload() //删除按钮 删除数据 deleteData(){ if(this.selectedRowNum==0){ .
4.4.2邻接表的深度优先遍历
qq_43192537的博客
11-13 651
#include <bits/stdc++.h> #include "Graph.cpp" using namespace std; int visited[MAXV]; void DFS(ALGraph *G, int v) { // 邻接表的DFS算法 ArcNode *p; cout << " " << v; visited[v] = 1; p...
dhu matlab
最新发布
04-09
DHU MATLAB是指东华大学（Donghua University）开发的一套基于MATLAB平台的工具包。它提供了一系列用于数据处理、数值计算、图像处理、信号处理等领域的函数和工具，方便用户进行科学计算和工程设计。DHU MATLAB具有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值