数据结构---图（邻接表）

最新推荐文章于 2024-04-21 19:51:15 发布
最新推荐文章于 2024-04-21 19:51:15 发布
阅读量2.1k 收藏 3
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dream_WHui/article/details/44020841
版权 
// Graph_Adjacency List.cpp : Defines the entry point for the console application.
/*-----CODE FOR FUN---------------
-------CREATED BY Dream_Whui------
-------2015-2-12--------------------*/

#include "stdafx.h"
#include <iostream>
#include <queue>
using namespace std;

#define      MAX_VERTEX_NUM    20

#define   TRUE             1
#define   FALSE            0
#define   OK               1
#define   ERROR            0
#define   OVERFLOW          -2
#define   INFEASIBLE      -1

typedef        char*    VertexType;
typedef        int        InfoType;

typedef enum
{
    DG,DN,UDG,UDN//有向图，有向网，无向图，无向网
}GraphKind;

typedef struct ArcNode
{    
    int                adjvex;        //该弧所指向的顶点的位置
    struct ArcNode    *nextarc;    //指向下一条弧的指针
    InfoType        *info;        //该弧相关信息的指针
}ArcNode;

typedef struct VNode
{
    VertexType        data;        //顶点信息
    ArcNode            *firstarc;    //指向第一条依附该顶点的弧的指针
}VNode, AdjList[MAX_VERTEX_NUM];

typedef struct
{
    AdjList    vertices;
    int        vexnum,arcnum;        //顶点数，弧数
    int        kind;                //图的种类标记
}ALGraph;

bool visited[MAX_VERTEX_NUM];

int CreateDG(ALGraph &G);//构造有向图
int CreateDN(ALGraph &G);//构造有向网
int CreateUDG(ALGraph &G);//构造无向图
int CreateUDN(ALGraph &G);//构造无向网

int CreateGraph(ALGraph &G)//采用邻接表表示法，构造图G
{
    int n;
    cout<<"创建有向图（0），有向网（1），无向图（2），无向网（3）"<<endl;
    cin>>n;
    switch(n)
    {
    case DG:
        G.kind = DG;
        return CreateDG(G);//有向图
    case DN:
        G.kind = DN;
        return CreateDN(G);//有向网
    case UDG:
        G.kind = UDG;
        return CreateUDG(G);//无向图
    case UDN:
        G.kind = UDN;
        return CreateUDN(G);//无向网
    default:
        return ERROR;
    }
}

int LocateVex(ALGraph G, VertexType v)    //顶点v在图中的位置
{
    int i;
    for(i=0; i<G.vexnum; i++)
    {
        if(strcmp(G.vertices[i].data,v)==0)
            return i;
    }
    return -1;
}

void CreateSub(ALGraph &G, int i, int j, int* w)//创建图(网)的辅助函数，构建第i个顶点到第j个顶点，权值w
{
    ArcNode *e, *p, *pre;
    e = (ArcNode*)malloc(sizeof(ArcNode));
    p = (ArcNode*)malloc(sizeof(ArcNode));
    pre = (ArcNode*)malloc(sizeof(ArcNode));
    e->adjvex = j;                        //
    e->nextarc = NULL;
    e->info = w;
    if(!G.vertices[i].firstarc)            //在头结点后插入
            G.vertices[i].firstarc = e;
        else                            
        {
            p = G.vertices[i].firstarc;
            if(p->adjvex < j)            //在第一个结点前插入（第一个结点指头结点后面的那个结点）
            {
                e->nextarc = p;
                G.vertices[i].firstarc = e;
            }
            else                        //在第以个结点后插入
            {
                pre = p;
                p = p->nextarc;
                while(p)
                {
                    if(p->adjvex < j)
                    {
                        e->nextarc = p;
                        pre->nextarc = e;
                        break;
                    }
                    pre = p;
                    p = p->nextarc;
                }
                if(!p)                    //在尾结点后插入
                    pre->nextarc = e;
            }
        }
}

int CreateDG(ALGraph &G)//构造有向图
{
    cout<<"输入顶点数，边数："<<endl;
    cin>>G.vexnum>>G.arcnum;
    int i,j,k,w;
    for(i=0; i<G.vexnum; i++)//构造顶点向量
    {
        cout<<"输入第"<<i+1<<"个顶点的名称：";
        G.vertices[i].data = (VertexType)malloc( sizeof(char) );
        cin>>G.vertices[i].data;
        G.vertices[i].firstarc = NULL;
    }
    char *v1, *v2;
    v1 = (char*)malloc(sizeof(char));
    v2 = (char*)malloc(sizeof(char));
    for(k=0; k<G.arcnum; k++)
    {
        cout<<"输入相连的边（v1,v2）:";
        cin>>v1>>v2;
        i = LocateVex(G,v1);//弧尾
        j = LocateVex(G,v2);//弧头
        w = 1;
        CreateSub(G,i,j,&w);
    }
    G.kind = DG;
    return OK;
}

int CreateUDG(ALGraph &G)//构造无向图
{
    cout<<"输入顶点数，边数："<<endl;
    cin>>G.vexnum>>G.arcnum;
    int i,j,k,w;
    for(i=0; i<G.vexnum; i++)//构造顶点向量
    {
        cout<<"输入第"<<i+1<<"个顶点的名称：";
        G.vertices[i].data = (VertexType)malloc( sizeof(char) );
        cin>>G.vertices[i].data;
        G.vertices[i].firstarc = NULL;
    }
    char *v1, *v2;
    v1 = (char*)malloc(sizeof(char));
    v2 = (char*)malloc(sizeof(char));
    for(k=0; k<G.arcnum; k++)
    {
        cout<<"输入相连的边（v1,v2）:";
        cin>>v1>>v2;
        i = LocateVex(G,v1);//边的起点
        j = LocateVex(G,v2);//边的终点
        CreateSub(G,i,j,&w);
        CreateSub(G,j,i,&w);
    }
    G.kind = UDG;
    return OK;
}

int CreateDN(ALGraph &G)//构造有向网
{
    cout<<"输入顶点数，边数："<<endl;
    cin>>G.vexnum>>G.arcnum;
    int i,j,k,w;
    for(i=0; i<G.vexnum; i++)//构造顶点向量
    {
        cout<<"输入第"<<i+1<<"个顶点的名称：";
        G.vertices[i].data = (VertexType)malloc( sizeof(char) );
        cin>>G.vertices[i].data;
        G.vertices[i].firstarc = NULL;
    }
    char *v1, *v2;
    v1 = (char*)malloc(sizeof(char));
    v2 = (char*)malloc(sizeof(char));
    for(k=0; k<G.arcnum; k++)
    {
        cout<<"输入相连的边及权值（v1,v2，w）:";
        cin>>v1>>v2>>w;
        i = LocateVex(G,v1);//弧尾
        j = LocateVex(G,v2);//弧头
        CreateSub(G,i,j,&w);
    }
    G.kind = DN;
    return OK;
}

int CreateUDN(ALGraph &G)//构造无向网
{
    cout<<"输入顶点数，边数："<<endl;
    cin>>G.vexnum>>G.arcnum;
    int i,j,k,w;
    for(i=0; i<G.vexnum; i++)//构造顶点向量
    {
        cout<<"输入第"<<i+1<<"个顶点的名称：";
        G.vertices[i].data = (VertexType)malloc( sizeof(char) );
        cin>>G.vertices[i].data;
        G.vertices[i].firstarc = NULL;
    }
    char *v1, *v2;
    v1 = (char*)malloc(sizeof(char));
    v2 = (char*)malloc(sizeof(char));
    for(k=0; k<G.arcnum; k++)
    {
        cout<<"输入相连的边及权值（v1,v2,w）:";
        cin>>v1>>v2>>w;
        i = LocateVex(G,v1);//边的起点
        j = LocateVex(G,v2);//边的终点
        CreateSub(G,i,j,&w);
        CreateSub(G,j,i,&w);
    }
    G.kind = UDN;
    return OK;
}

VertexType GetVex(ALGraph G, int v)//返回图中第V个顶点
{
    if(v<0 || v>G.vexnum)
        return NULL;
    return G.vertices[v-1].data;
}

int PutVex(ALGraph &G, VertexType v, VertexType value)//修改图中顶点v的名称为value
{
    int i;
    i = LocateVex(G,v);
    if(i<0)
        return ERROR;
    else
        strcpy(G.vertices[i].data,value);
    return OK;
}

ArcNode* FirstAdjVex(ALGraph G, VertexType v)//返回顶点V的第一个邻接点
{
    int i;
    i = LocateVex(G,v);
    if(i<0)
        return NULL;
    else
        return G.vertices[i].firstarc;
}

ArcNode* NextAdjVex(ALGraph G, VertexType v, VertexType w)//返回顶点V的(相对于w)下一个邻接点
{
    int i,j,k;
    i = LocateVex(G,v);
    j = LocateVex(G,w);
    if(i<0 || j<0)
        return NULL;
    ArcNode *p;
    p = G.vertices[i].firstarc;
    while(p)
    {
        if(p->adjvex == j)
            return p->nextarc;
        p = p->nextarc;
    }
}

void InsertVex(ALGraph &G, VertexType v)//插入顶点
{
    G.vertices[G.vexnum].data = (VertexType)malloc( sizeof(char) );
    strcpy(G.vertices[G.vexnum].data,v);
    G.vertices[G.vexnum].firstarc = NULL;
    G.vexnum++;
}

int DeleteVex(ALGraph &G, VertexType v)//删除顶点
{
    int i,k,j;
    k = LocateVex(G,v);
    if(G.kind < 2)//有向
        j = 1;
    else        //无向
        j = 0;
    if(v<0)
        return ERROR;
    ArcNode *p,*q;
    p = G.vertices[k].firstarc;//p指向顶点v的链表
    while(p)                    //删除顶点v的链表
    {
        q = p;
        G.vertices[k].firstarc = p->nextarc;
        p = p->nextarc;
        free(q);
        G.arcnum--;            //边数减1
    }
    for(i=0; i<G.vexnum; i++)//对邻接表其余顶点链表操作，删除有顶点v的指针
    {
        p = G.vertices[i].firstarc;
        if(p)            
        {
            if(p->adjvex == k)    //删除第一个结点（顶点v是第一个结点）
            {
                G.vertices[i].firstarc = p->nextarc;
                free(p);
                G.arcnum = G.arcnum - j;
            }
            else                //删除第一个后的结点（顶点v不是第一个结点）
            {    
                q = p;
                p = p->nextarc;
                while(p)
                {
                    if(p->adjvex == k)
                    {
                        q->nextarc = p->nextarc;
                        free(p);
                        G.arcnum = G.arcnum - j;//有向：边再减1；无向：不用再减1
                        break;
                    }
                    q = p;
                    p = p->nextarc;
                }
            }
        }
    }
    for(i=k; i<G.vexnum-1; i++)//邻接表第k个位置后都往前移
        G.vertices[i] = G.vertices[i+1];
    G.vexnum--;                    //顶点数减1
    for(i=0; i<G.vexnum; i++)    //由于邻接表位置的挪动，导致各顶点链表中的adjvex域都错位，应重新调整
    {
        p = G.vertices[i].firstarc;
        while(p)
        {
            if(p->adjvex > k)    //第k个位置后的链表都往前移了，因此p->adjvex > k的情况下，都减1
                p->adjvex = p->adjvex -1;
            p = p->nextarc;
        }
    }
}

int InsertArc(ALGraph &G, VertexType v, VertexType w)//插入一条边或弧
{
    int i,j,weight;
    i = LocateVex(G,v);//尾
    j = LocateVex(G,w);//头
    if(i<0 || j<0)
        return ERROR;
    G.arcnum++;
    if(G.kind % 2 == 1)//网
    {
        cout<<"输入权值：";
        cin>>weight;
    }
    else            //图
        weight = 1;
    if(G.kind < 2)//有向
        CreateSub(G,i,j,&weight);
    else         //无向
    {
        CreateSub(G,i,j,&weight);
        CreateSub(G,j,i,&weight);
    }
    return OK;
}

void DeleteSub(ALGraph &G, int i, int j)//删除边或弧的辅助函数
{
    ArcNode *p, *pre;
    p = G.vertices[i].firstarc;
    if(p->adjvex == j)
    {    
        G.vertices[i].firstarc = p->nextarc;
        free(p);
    }
    else
    {
        pre = p;
        p = p->nextarc;
        while(p)
        {
            if(p->adjvex == j)
            {
                pre->nextarc = p->nextarc;
                free(p);
                break;
            }
            pre = p;
            p = p->nextarc;
        }
    }
}

int DeleteArc(ALGraph &G, VertexType v, VertexType w)//删除一条边
{
    int i,j,k;
    i = LocateVex(G,v);//尾
    j = LocateVex(G,w);//头
    if(i<0 || j<0)
        return ERROR;
    if(G.kind < 2)//有向
        DeleteSub(G,i,j);
    else        //无向
    {
        DeleteSub(G,i,j);
        DeleteSub(G,j,i);
    }
    G.arcnum--;
    return OK;
}

void Display(ALGraph G)
{
    int i;
    ArcNode *t;
    cout<<"边数："<<G.arcnum<<endl;
    cout<<"顶点数："<<G.vexnum<<endl;
    for(i=0; i<G.vexnum; i++)
    {
        cout<<i+1<<": "<<G.vertices[i].data;
        t = G.vertices[i].firstarc;
        while(t)
        {
            cout<<G.vertices[t->adjvex].data;
            t = t->nextarc;
        }
        cout<<endl;
    }
}

void Visit(VertexType e)
{
    cout<<e;
}

void DFS(ALGraph G, int i)
{
    visited[i] = TRUE;
    Visit(G.vertices[i].data);
    ArcNode *w;
    for(w=FirstAdjVex(G,G.vertices[i].data); w!=NULL; w=NextAdjVex(G,G.vertices[i].data,G.vertices[w->adjvex].data))
    {
        if(!visited[w->adjvex])
            DFS(G,w->adjvex);
    }
}


void DFSTraverse(ALGraph G, void(*Visit)(VertexType))//深度优先遍历
{
    int i;
    for(i=0; i<G.vexnum; i++)
        visited[i] = FALSE;
    for(i=0; i<G.vexnum; i++)
    {
        if(!visited[i])
            DFS(G,i);
    }
    cout<<endl;
}

void BFSTraverse(ALGraph G, void(*Visit)(VertexType))//广度优先搜索算法
{
    int i,u;
    ArcNode *w;
    for(i=0; i<G.vexnum; i++)
        visited[i] = FALSE;
    queue<int> Q;
    for(i=0; i<G.vexnum; i++)
    {
        if(!visited[i])
        {
            visited[i] = TRUE;
            Visit(G.vertices[i].data);
            Q.push(i);
            while(!Q.empty())
            {
                u = Q.front();
                Q.pop();
                for(w=FirstAdjVex(G,G.vertices[u].data); w!=NULL; w=NextAdjVex(G,G.vertices[u].data,G.vertices[w->adjvex].data))
                {
                    if(!visited[w->adjvex])
                    {
                        visited[w->adjvex] = TRUE;
                        Visit(G.vertices[w->adjvex].data);
                        Q.push(w->adjvex);
                    }
                }
            }
        }
    }
    cout<<endl;
}

int main(int argc, char* argv[])
{
    ALGraph G;
    CreateGraph(G);
    Display(G);
    DFSTraverse(G,Visit);
    BFSTraverse(G,Visit);
    return 0;
}

Dream_WHui
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言数据结构-邻接表的广度优先遍历
12-13
C语言数据结构-邻接表的广度优先遍历
怎么画邻接表？不用邻接矩阵也能画？
naozibuok的博客
05-16 1万+
需要注意的是如果一个点只被指，不指其他点，那就返回上一个出发点，从此出发点指向另一个点，如果这个出发点的边都被访问过，那就再返回上上一个出发点，直到所有边访问完毕，实际上这是一个回溯的过程。⑤v4也不指向其他结点，那么回溯到v1，v1->v2，v1->v4，都已经访问过，再回溯到v0。③将v2作为第三出发点，发现v2不指向其他结点，那么回溯到v1。2.从第一出发点按箭头指向任意一点作为第二出发点。①我以v0作为第一出发点，指向v1，即。②将v1作为第二出发点，指向v2，即。至此，所有边访问完毕。
有向图的邻接矩阵和邻接表画法
热门推荐
qq_44667165的博客
03-27 7万+
本例子展示有向邻接表画邻接矩阵，反过来也是如此 大三时自学了了数据结构中的图，发现图中有邻接矩阵和邻接表，作为笔记记录下来 如下图所示，给了一个有向邻接表，求邻接矩阵 怎么做呢？ 第一步：和无向图类似，都是先找到你的图里面值的范围， 画出方形框，如下图所示，圆框中的值为0、1、2、3、4 第二步：从0邻接点值开始寻找与它相邻的点，遇到本身的点直接写0，箭头指向的点写上连接线上的数字，无本身箭头指向的直接写上∞ 如下图所示从0开始，能指向的只有3、7 最后：根据以上的方法依次写出1 2 3 4的邻接矩阵
数据结构-C语言描述（邻接表）
最新发布
MaverickCoder的博客
04-21 1698
邻接表是一种表示图的数据结构，事实上邻接表可以用于有向图、无向图、带权图、无权图。 邻接表表示法的优点主要有空间效率、遍历效率高。
使用邻接表创建无向图和有向图
千言万语ROOM
05-24 1万+
图的邻接表表示法： 邻接表(Adjacency List) 是图的 一 种链式存储结构。在邻接表中，对图中每个顶点V建立一个单链表，把与 V相邻接的顶点放在这个链表中。邻接表中每个单链表的第一个结点存放有关顶点的信息， 把这 一 结点看成链表的表头， 其余结点存放有关边的信息， 这样邻接表便由两部分组成：表头结点表和边表。 (1) 表头结点表：由所有表头结点以顺序结构的形式存储， 以便可以随机访问任 一 顶点的边链表。表头结点包括数据域 (data) 和链域 (firstarc) 两部分。其中， 数据域
【数据结构】图-图的存储_邻接表（图解、c++、java）
扑腾的江鱼复习仓库
03-09 3517
URLeisure的图的存储_邻接表“完美”复习资料。
用邻接表表示图
qq_45577911的博客
10-04 712
邻接表采用链表的方式对每个结点的邻接点进行存储，每个顶点所带领的一个链表主要由表头结点和边结点构成。 表头结点结构： 边结点结构： 例如： 代码如下： #include<stdio.h> #define maxvertex 20 typedef struct ArcNode //边结点 { int adjvex; //邻接点域 struct ArcNode...
数据结构学习--图的邻接矩阵和邻接表存储
06-25
在数据结构的学习中，图是一种非常重要的非线性数据结构，用于表示对象之间的关系。图的存储方式主要有两种：邻接矩阵和邻接表。这两种存储方式各有优缺点，适用于不同的场景。 邻接矩阵是一种二维数组，其中的元素...
数据结构-c语言-带main函数-图7.3-图的遍历-广度优先搜索-队列-邻接表-无向图。
06-24
在本文中，我们将深入探讨如何使用C语言实现无向图的广度优先搜索（BFS）遍历，其中涉及到了数据结构如邻接表、队列，并使用了CFree软件进行辅助开发。首先，让我们详细了解这些概念。 **数据结构：邻接表** 邻接表...
数据结构-c语言-带main函数-图7.2-图的存储结构-图的邻接表的创建-无向图。
06-24
数据结构 - 图的存储结构 - 邻接表的创建 - 无向图。 在数据结构中，图是一种非常重要的数据结构，它广泛应用于计算机科学和信息技术领域中。在本节中，我们将讨论图的存储结构，并使用 C 语言实现图的邻接表的创建...
数据结构与算法实验（C++）：图的邻接表实验-代码
01-18
1）熟练掌握图的邻接表存储结构的实现； 2）熟练掌握基于邻接表的图的基本操作算法实现； 3）灵活使用有向图来解决具体的问题。 （2）实验内容： 1）定义有向图的邻接表类，封装图的基本操作算法，包括： a.创建、...
数据结构-图的邻接表的定义与实现
m0_61789994的博客
05-18 4239
邻接表是一种基于链表的存储方式，它将每个顶点的所有邻接点存储在一个链表中。具体来说，邻接表由一个顶点数组和一个边链表组成，顶点数组中的每个元素表示一个顶点，边链表中的每个结点表示一条边。// 邻接表中的边结构体int to;// 目标节点int weight;// 权重// 邻接表中的节点结构体int val;// 节点的值// 邻居节点// 图的邻接表结构体// 节点集合i < n;return 0;
数据结构 （图）
trammelsol的博客
06-15 543
数据结构（图） 图的创建，遍历，AOV网创建 采用C语言，以便熟练stack栈的底层实现 AOV网：用顶点表示活动，用弧表示活动间的优先关系的有向图称为顶点表示活动的图（Activity On Vertex Network），简称AOV网。 拓扑排序：将AOV网中所有的顶点排成一个线性序列，该序列满足：若在该AOV网中由顶点Vi到顶点Vj有一条路径，则在改线性序列中的顶点Vi必定在顶点Vj之前。简而言之，AOV网解决的是先后顺序问题。是求关键路径的基础。 #include <stdio.h> #
邻接表、十字链表、邻接多重表—图的存储结构
wmy0217_的博客
02-16 6690
文章目录邻接表1、邻接表表示法2、无向图的邻接表3、有向图的邻接表4、练习5、邻接表的结构类型定义6、采用邻接表表示法创建无向网7、邻接表特点8、邻接矩阵与邻接表表示法的关系十字链表邻接多重表 邻接表 1、邻接表表示法 邻接表是一种图的链式存储结构。在邻接表中，对图中每个顶点 vi 建立一个单链表，把与 vi 相邻接的顶点放在这个链表中。 邻接表中每个单链表的第一个结点存放有关顶点的信息，把这...
数据结构（廿三） -- C语言版 -- 图 - 图的存储结构 -- 邻接表、逆邻接表
青椒*^_^*凤爪爪的博客
08-15 1万+
在图中任何两个顶点之间都可能存在联系，所以图的存储结构应该需要根据具体问题的要求来进行设计。从图的逻辑结构定义来看，图中任何一个顶点都可以看成是第一个顶点。常用的存储结构有邻接矩阵、邻接表（逆邻接表）、十字链表、邻接多重表、 边集数组。那么本博文将带你就 “邻接表（逆邻接表）” 来窥探一二。。。
【数据结构基础】图 - 基础和Overview
DeveloperFire的博客
02-03 876
图(Graph)是由顶点和连接顶点的边构成的离散结构。在计算机科学中，图是最灵活的数据结构之一，很多问题都可以使用图模型进行建模求解。例如: 生态环境中不同物种的相互竞争、人与人之间的社交与关系网络、化学上用图区分结构不同但分子式相同的同分异构体、分析计算机网络的拓扑结构确定两台计算机是否可以通信、找到两个城市之间的最短路径等等。
Java数据结构-有向图实验，使用邻接表构建有向图
zs18056175178的博客
12-04 1160
算法设计 采用邻接表存储有向图，设计算法判断任意两个顶点间是否存在路径。 提示： 1.建立图 2.利用深度优先遍历，寻找到一个节点 3.基于找到的节点，查找邻接表，判断是否存在这样的路径
【数据结构】采用邻接表构建无向图
jianbiao1483的博客
08-22 2034
【代码】【数据结构】采用邻接表构建无向图。
十字链表与邻接多重表的画法
qq_44193969的博客
11-06 8255
文章目录前言一、十字链表1.画邻接表2.增加弧节点的域3.自己指向自己二、邻接多重表1.画顶点2.画边3.自己指向自己 前言 近期一直在构建算法技能树的数据，借此机会，重新把数据结构与算法又温习了一遍，在看到十字链表与邻接多重表的画法时，十分的不理解，在C站找资料时，发现也看不懂，于是上B站，终于明白了十字链表与多重邻接表的画法。 一、十字链表 我们以下面的有向图为例来进行讲解 首先我们有几个定义要搞清楚： 如果： 则我们称V0是弧尾， v3是弧头 反之，如果： 则我们称v1是弧尾，v0是弧头。 顶
数据结构（C语言版） 第六章 图 知识梳理 + 习题详解1
08-03
"数据结构（C语言版） 第六章 图 知识梳理 习题详解 本文主要总结了《数据结构（C语言版）》第六章中关于图的知识内容。图是由顶点和边组成的抽象网络，表示各顶点之间的关联关系。本章主要介绍了图的基本概念、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值