【数据结构】 循环双链表的基本操作 （C语言版）

最新推荐文章于 2024-05-24 00:00:00 发布
最新推荐文章于 2024-05-24 00:00:00 发布
阅读量738 收藏 14
点赞数 9
文章标签： 数据结构 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56814370/article/details/135732750
版权

目录

一、循环双链表

1、循环双链表的定义：

2、循环双链表的优缺点：

二、循环双链表的基本操作算法（C语言） 

  1、宏定义

 2、创建结构体

3、循环双链表的初始化 

4、循环双链表按位查找

5、循环双链表插入

6、循环双链表查找

7、循环双链表删除

8、求循环双链表长度

9、循环双链表清空

10、循环双链表销毁

11、头插法建立循环双链表

12、尾头插法建立循环双链表

13、输出链表元素

三、循环双链表的基本操作完整代码（C语言）

四、运行结果

一、循环双链表

1、循环双链表的定义：

循环双链表是一种特殊的双链表，其特点是尾节点的指针域指向头结点，形成一个环状结构。这种数据结构允许从链表的任意节点出发，通过后移操作，遍历整个循环双链表。

2、循环双链表的优缺点：

循环双链表的优点：

  1. 可以从任意节点出发，遍历整个链表，提高了遍历的灵活性。
  2. 在某些应用场景中，循环双链表可以提供更高的访问效率。

循环双链表的缺点：

  1. 插入和删除节点需要更多的时间来调整指针，因为需要维护链表的环状结构。
  2. 循环双链表的空间利用率相对较低，因为需要额外的指针来存储前驱和后继节点的信息。

二、循环双链表的基本操作算法（C语言） 

  1、宏定义
#define OK 1
#define ERROR 0

typedef char ElemType;
typedef int Status;
 2、创建结构体
/**定义一个具有前驱指针和后继指针的双链表的结构体**/
typedef struct DuLNode {
    ElemType data;  //数据域
    struct DuLNode *prior; //指向直接前驱
    struct DuLNode *next; //指向直接后继
    //    struct DuLNode *prior,*next;		//前驱指针和后继指针
} DuLNode, *DuLinkList; //前者强调这是结点，后者强调这是链表
3、循环双链表的初始化 
//循环双链表初始化
Status InitList(DuLinkList &head) {
    head = new DuLNode;
    head->prior = head;//循环双链表
    head->next = head;
    return OK;
}
4、循环双链表按位查找
//按位查找
DuLNode *GetElem(DuLinkList L, int i) {
    int j = 1;//因为有头结点，所以从1开始遍历
    if (i < 1) {//判断查找的位置是否合法
        printf("数值非法");
    }
    DuLNode *p = L->next;//初始化结点指针
    while (p != NULL && j < i) {
        p = p->next;
        j++;
    }
    return p;
}
5、循环双链表插入
//插入
Status ListInsert_Dul(DuLinkList &head, int i, ElemType e) {
   DuLinkList p = head;
   int j=0;
    while (p && (j<i-1)){
       p=p->next;
       j++;
   }
    if (!p || j > i-1){
        return ERROR;
   }
    //DuLinkList p = GetElem(head, i);
    if (!p) {
        return ERROR;
    }
    DuLNode *s = new DuLNode;
    s->data = e;
    s->prior = p->prior;
    p->prior->next = s;
    s->next = p;
    p->prior = s;

    return OK;
}
6、循环双链表查找
//查找
int LocateLinkListElem(DuLinkList head, ElemType e) {
    DuLinkList p = head->next;
    int j = 1;
    while (p != head && (p->data != e)) {//p != L p!=NULL
        p = p->next;
        j++;
    }
    if (p == head) { //p==L  !p<=>p==NULL
        return 0;
    }
    return j;
}
7、循环双链表删除
//删除
Status ListDelete_DuL(DuLinkList &head, int i, ElemType &e) {
    DuLinkList p=head;
    int j=0;
    while (p->next != head  && j <= i){  //p != L
        p=p->next;
        j++;
    }
    if (p->next == head){ //p==L
        return ERROR;
    }
    //调用按位查找函数
//    DuLinkList p = GetElem(head, i);
    if (!p) {
        return ERROR;
    }
    e = p->data;
    p->prior->next = p->next;
    p->next->prior = p->prior;
    delete p;
    return OK;
}
8、求循环双链表长度

//求双链表长度
Status GetLinkListLength(DuLinkList head) {
    DuLinkList p = head->next;
    int length = 0;
    while (p != head) {   //p!=NULL          //单链表不为空表时
        length++;
        p = p->next;
    }
    return length;
}
9、循环双链表清空
//清空
Status ClearList(DuLinkList &head) {
    DuLinkList p = head->next;
    DuLinkList q;
    while (p != head) { //p != L  p!=NULL
        q = p;
        p = p->next;
        delete q;
    }
    head->prior = head;
    head->next = head; //链表为空
    return OK;
}
10、循环双链表销毁
//销毁
Status DestroyList(DuLinkList &head) {

    DuLinkList p, q;//初始化两个指针，p用来free释放，q用来在p释放后将p指针指向下一个
    p = head->next;//删除带头链表头结点不删除
    q = p;
    while (p != head) {
        q = p->next;  //提前将q指向下一个
        delete p;    //释放p
        p = q;        //将p指向q所指向的下一个
    }
    head->next = NULL; //头结点指向NULL
    return OK;
    //printf("\n销毁成功\n");
}
11、头插法建立循环双链表
void CreateDLinkList_H(DuLinkList &head, int n) {
    InitList(head);
    for (int i = 0; i < n; i++) {
        DuLNode *p = new DuLNode;
        //scanf("%c",&p->data);
        p->data = getche();
        //cin >> p->data;
        p->next = head->next;
        if (head->next != NULL) {
            head->next->prior = p;
        }
        p->prior = head;
        head->next = p;
    }
}
12、尾头插法建立循环双链表
void CreateDoubleList_R(DuLinkList &head, int n) {
    InitList(head);
    DuLinkList r = head;  // 初始化 r 指针为头结点
    for (int i = 0; i < n; i++) {
        DuLNode *p = new DuLNode;
        //scanf("%c",&p->data);
        p->data = getche();
        //cin >> p->data;
        //p->next=NULL   p->next=head
        p->next = r->next;
        if (r->next != NULL) {
            r->next->prior = p;
        }
        p->prior = r;
        r->next = p;
        r = p;  // r 指向新插入的节点，更新尾指针
    }
    r->next = head;  // 将尾节点的 next 指针指向头结点，形成循环
}
13、输出链表元素
//输出链表元素
void printLinkList(DuLinkList head) {
    DuLinkList p = head->next;
    while (p != head) { //p != L
        printf("%c", p->data);
        p = p->next;
    }
    printf("\n");
}

三、循环双链表的基本操作完整代码（C语言）

#include <stdio.h>
#include <conio.h>//getche()

#define OK 1
#define ERROR 0

typedef char ElemType;
typedef int Status;

/**定义一个具有前驱指针和后继指针的双链表的结构体**/
typedef struct DuLNode {
    ElemType data;  //数据域
    struct DuLNode *prior; //指向直接前驱
    struct DuLNode *next; //指向直接后继
    //    struct DuLNode *prior,*next;		//前驱指针和后继指针
} DuLNode, *DuLinkList; //前者强调这是结点，后者强调这是链表


//双链表初始化
Status InitList(DuLinkList &head) {
    head = new DuLNode;
    head->prior = head;//循环双链表
    head->next = head;
//    head->prior = NULL;
//    head->next = NULL;
    return OK;
}


//功能菜单
int choice() {
    printf("==================================\n");
    printf("         双链表操作功能菜单        \n");
    printf("1、插入元素  2、查询表长  3、按位查找\n");
    printf("4、按值查找  5、删除元素  6、销毁链表\n");
    printf("7、清空链表  8、批量插入  9、链表元素\n");
    printf("10、头插法创建双链表11、尾插法创建双链表\n");
    printf("==================================\n");
    return 0;
}

//按位查找
DuLNode *GetElem(DuLinkList L, int i) {
    int j = 1;//因为有头结点，所以从1开始遍历
    if (i < 1) {//判断查找的位置是否合法
        printf("数值非法");
    }
    DuLNode *p = L->next;//初始化结点指针
    while (p != NULL && j < i) {
        p = p->next;
        j++;
    }
    return p;
}

//插入
Status ListInsert_Dul(DuLinkList &head, int i, ElemType e) {
//    DuLinkList p = head;
//    int j=0;
//    while (p && (j<i-1)){
//        p=p->next;
//        j++;
//    }
//    if (!p || j > i-1){
//        return ERROR;
//    }
    DuLinkList p = GetElem(head, i);
    if (!p) {
        return ERROR;
    }
    DuLNode *s = new DuLNode;
    s->data = e;
    s->prior = p->prior;
    p->prior->next = s;
    s->next = p;
    p->prior = s;

    return OK;
}

//查找
int LocateLinkListElem(DuLinkList head, ElemType e) {
    DuLinkList p = head->next;
    int j = 1;
    while (p != head && (p->data != e)) {//p != L p!=NULL
        p = p->next;
        j++;
    }
    if (p == head) { //p==L  !p<=>p==NULL
        return 0;
    }
    return j;
}

//删除
Status ListDelete_DuL(DuLinkList &head, int i, ElemType &e) {
//    DuLinkList p=head;
//    int j=0;
//    while (p->next != head  && j <= i){  //p != L
//        p=p->next;
//        j++;
//    }
//    if (p->next == head){ //p==L
//        return ERROR;
//    }
    //调用按位查找函数
    DuLinkList p = GetElem(head, i);
    if (!p) {
        return ERROR;
    }
    e = p->data;
    p->prior->next = p->next;
    p->next->prior = p->prior;
    delete p;
    return OK;
}

//求双链表长度
Status GetLinkListLength(DuLinkList head) {
    DuLinkList p = head->next;
    int length = 0;
    while (p != head) {   //p!=NULL          //单链表不为空表时
        length++;
        p = p->next;
    }
    return length;
}


//清空
Status ClearList(DuLinkList &head) {
    DuLinkList p = head->next;
    DuLinkList q;
    while (p != head) { //p != L  p!=NULL
        q = p;
        p = p->next;
        delete q;
    }
    head->prior = head;
    head->next = head; //链表为空
    return OK;
}

//销毁
Status DestroyList(DuLinkList &head) {

    DuLinkList p, q;//初始化两个指针，p用来free释放，q用来在p释放后将p指针指向下一个
    p = head->next;//删除带头链表头结点不删除
    q = p;
    while (p != head) {
        q = p->next;  //提前将q指向下一个
        delete p;    //释放p
        p = q;        //将p指向q所指向的下一个
    }
    head->next = NULL; //头结点指向NULL
    return OK;
    //printf("\n销毁成功\n");
}

//头插法创建循环双链表
void CreateDLinkList_H(DuLinkList &head, int n) {
    InitList(head);
    for (int i = 0; i < n; i++) {
        DuLNode *p = new DuLNode;
        //scanf("%c",&p->data);
        p->data = getche();
        //cin >> p->data;
        p->next = head->next;
        if (head->next != NULL) {
            head->next->prior = p;
        }
        p->prior = head;
        head->next = p;
    }
}

//尾插法创建循环双链表
void CreateDoubleList_R(DuLinkList &head, int n) {
    InitList(head);
    DuLinkList r = head;  // 初始化 r 指针为头结点
    for (int i = 0; i < n; i++) {
        DuLNode *p = new DuLNode;
        //scanf("%c",&p->data);
        p->data = getche();
        //cin >> p->data;
        //p->next=NULL   p->next=head
        p->next = r->next;
        if (r->next != NULL) {
            r->next->prior = p;
        }
        p->prior = r;
        r->next = p;
        r = p;  // r 指向新插入的节点，更新尾指针
    }
    r->next = head;  // 将尾节点的 next 指针指向头结点，形成循环
}

//输出链表元素
void printLinkList(DuLinkList head) {
    DuLinkList p = head->next;
    while (p != head) { //p != L
        printf("%c", p->data);
        p = p->next;
    }
    printf("\n");
}

int main() {

    DuLinkList list;

    printf("双链表正在初始化....\n");
    int InitStatus = InitList(list);
    if (InitStatus == OK) {
        printf("双链表初始化成功！\n");
    } else {
        printf("双链表初始化失败！\n");
    }

    choice();

    while (1) {
        int flag;
        printf("请输入所需的功能编号：\n");
        scanf("%d", &flag);

        switch (flag) {//通过开关进行功能选择
            case 1: {//插入元素
                //ListInsert_Dul(list,1,'a');
                int insertIndex;
                ElemType inserElem;
                printf("请输入插入元素位置及插入元素(请在英文状态下输入例如:1,a): \n");
                scanf("%d,%c", &insertIndex, &inserElem);
                Status InsertS = ListInsert_Dul(list, insertIndex, inserElem);
                if (InsertS == OK) {
                    printf("向双循环链表%d个位置,插入元素为%c成功！\n\n", insertIndex, inserElem);
                } else {
                    printf("向双循环链表插入元素失败！\n\n");
                }
            }
                break;
            case 2: {//求单链表的长度
                int length = GetLinkListLength(list);
                printf("循环双链表的长度为:%d。 \n\n", length);
            }
                break;
            case 3: {//取值
                Status GetIndex;
                printf("请输入需要查询的元素的位置：\n");
                scanf("%d", &GetIndex);
                DuLinkList GetStatus = GetElem(list, GetIndex);
                ElemType GetElem = GetStatus->data;
                if (GetStatus != NULL) {
                    printf("从双链表中获取第%d位置元素成功，所获取到的元素为：%c。\n\n", GetIndex, GetElem);
                } else {
                    printf("从双链表中获取第%d位置元素失败！\n\n", GetIndex);
                }
            }
                break;
            case 4: {//查找
                ElemType LocateElem;
                printf("请输入想要查找元素：\n");
                getchar();    //用于接收回车
                scanf("%c", &LocateElem);
                Status LocateIndex = LocateLinkListElem(list, LocateElem);
                if (LocateIndex > 0) {
                    printf("从双链表中查找元素%c成功，它在循环链表中的位置为第%d个！\n\n", LocateElem, LocateIndex);
                } else {
                    printf("从双链表中查找元素%c失败！\n\n", LocateElem);
                }
            }
                break;
            case 5: {//删除
                //ListDelete_DuL(list,1);
                Status DeleteIndex;
                printf("请输入想要删除元素的位置：\n");
                scanf("%d", &DeleteIndex);
                ElemType DeleteElem;
                ElemType DeleteStatus = ListDelete_DuL(list, DeleteIndex, DeleteElem);
                if (DeleteStatus == OK) {
                    printf("删除双链表第%d个位置的元素成功，删除的元素为：%c。\n\n", DeleteIndex, DeleteElem);
                } else {
                    printf("删除双链表第%d个位置的元素失败！\n\n", DeleteIndex);
                }
            }
                break;
            case 6: {//销毁
                Status DestoryStatus = DestroyList(list);
                if (DestoryStatus == OK) {
                    printf("双环链表销毁成功！\n\n");
                } else {
                    printf("双链表销毁失败！\n\n");
                }
            }
                break;
            case 7: {//清空
                Status ClearStatus = ClearList(list);
                if (ClearStatus == OK) {
                    printf("双链表清空成功！\n\n");
                } else {
                    printf("双链表清空失败！\n\n");
                }
            }
                break;
            case 8: {//批量插入
                int on;
                printf("请输入想要插入的元素个数：\n");
                scanf("%d", &on);
                ElemType array[on];
                for (int i = 1; i <= on; i++) {
                    getchar();
                    printf("向双链表第%d个位置插入元素为:", (i));
                    scanf("%c", &array[i]);
                }

                for (int i = 1; i <= on; i++) {
                    Status InsertStatus = ListInsert_Dul(list, i, array[i]);
                    if (InsertStatus == OK) {
                        printf("向双链表第%d个位置插入元素%c成功！\n", i, array[i]);
                    } else {
                        printf("向双链表第%d个位置插入元素%c失败！\n", i, array[i]);
                    }
                }
            }
                break;
            case 9: {//输出链表元素
                printLinkList(list);
            }
                break;
            case 10: {//头插法创建双链表
                //getchar();
                DuLinkList L;
                printf("请输入五个字符：\n");
                CreateDLinkList_H(L, 5);
                int length = GetLinkListLength(L);
                printf("\n循环双链表的长度为:%d。 \n", length);
                printf("循环双链表的元素为:");
                printLinkList(L);
                printf("\n");
            }
                break;
            case 11: {//尾插法创建双链表
                DuLinkList L;
                printf("请输入五个字符：\n");
                CreateDoubleList_R(L, 5);
                int length = GetLinkListLength(L);
                printf("\n循环双链表的长度为:%d。 \n", length);
                printf("循环双链表的元素为:");
                printLinkList(L);
                printf("\n");
            }
                break;
            default: {
                printf("输入错误，无此功能，请检查输入:\n\n");
            }
        }
    }

    return 1;

}

四、运行结果

 

 

殊迟
关注
  • 9
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
循环双链表详解
Arrow的博客
03-20 7183
循环双链表创建以及排序 1. 创建双链表 完整代码如下 #include<stdio.h> #include<stdlib.h> typedef struct node { int data; struct node *nex; struct node *pre; }NODE; void Add_Data(NODE*,int)； int main() ...
【数据结构】循环单链表的实现（C语言）
( :3 )
09-29 3678
 循环单链表应掌握以下基本操作： 1、建立一个空的循环单链表。 2、获得循环单链表的最后一个结点的位置。 3、输出循环单链表中各结点的值。 4、在循环单链表中查找值为x的结点。 5、在循环单链表中第i个结点后插入值为x的新结点。 6、在循环单链表中删除值为x 的结点。 以下是头文件：（可以有选择的看，有很多算法） #ifndef CIRCLE_HEAD_LINK_H_INCLUD...
循环双链表的基本运算算法（增删改查）
qq_41960161的博客
10-08 1874
目的：领会循环双链表存储结构和掌握循环双链表中的各种基本运算算法。 如果双链表的操作会了，单链表那是手到擒来，很简单。 下面用一个实验来实现，该实现完成了以下功能： 1、初始化循环双链表h。 2、依次采用尾插法插入a、b、c、d、e五个元素。 3、输出循环双链表h。 4、输出循环双链表h的长度。 5、判断循环双链表是否为空。 6、输出循环双链表h的第3个元素。 7、输出元素a的位置。 8、在第4个元素的位置上插入f元素。 9、输出循环双链表h。 10、删除循环双链表h的第3个元素。 11、输出循环双链表h。
实验五：实现循环双链表各种基本运算的算法
最新发布
About_Yu的博客
05-24 1132
目的:领会循环双链表存储结构和掌握循环双链表中各种基本运算算法设计。 内容:编写一个程序cdinklist.cpp,实现循环双链表的各种基本运算和整体建表算法(假设循环双链表的元素类型ElemType为char)
数据结构（五）——双链表与循环链表
流逝
08-03 1384
数据结构（五) —— 双链表和循环链表
双向循环链表操作的实现
m0_53676388的博客
01-24 1863
对双向循环列表进行如下操作： 1.建立一个空表。 2.在第i个位置插入新的元素x。 3.删除第i个位置上的元素。 4.取第i个位置上的元素。 5.返回元素x第一次出现在双向循环链表中的位置号。 6.求双向循环链表的长度，即元素个数。 7.输出双向循环链表中所有的元素值。 8.实现双向循环链表的就地逆置。
C语言实现双向带头循环链表的增删查改
Tlzns的博客
05-13 155
链表有很多种结构，而双向带头循环链表的结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。而且这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而会简单
链表插入删除操作(单链表，双链表+循环链表)
ResumeProject的博客
10-26 2003
在p后插入s在p后插入s在p后插入s s->next = p->next; p->next=s; 删除s删除s删除s p->next = s->next; free(s); 在p后插入s在p后插入s在p后插入s s->next = p->next; s->prior = p; p->next =s; s->next->prior =s; 删除s删除s删除s s->prior->next = s->next; s-&.
【数据结构-C语言】双向循环链表
sakura0908的博客
03-02 1142
对链表而言，双向均可遍历是最方便的，另外首尾相连循环遍历也可打打增加链表操作的便捷性。因此，双向循环链表，是在实际运用中最常见的链表形态。
数据结构-c语言实现带头循环双链表增、删、查、改等基本操作（超长超详细）
m0_62211222的博客
08-13 523
链表的结构体中存储了两个指针，一个指向前驱节点，另一个指向后继节点。插入或者删除的时候一定要记得断言，否则可能会出现错误，但是找不到哪里出错。双链表是在顺序表的基础上更新的一种存储结构，他的优点是：在任意位置插入效率高，并且按需申请空间，不会造成空间浪费。...
【数据结构】之 链表 带头双向循环 （C语言）（含完整代码）
weixin_53936115的博客
12-30 1160
1、基本概念： 带头双向循环链表：一个节点有两个指针，一个指向前一个节点（前指针）一个指向下一个节点（后指针）；有一个头结点，该节点不存储如何值，头结点的前指针指向该链表的最后一个节点。最后一个节点的后指针指向头结点。 基本逻辑结构： 2、代码实现 2.1 准备工作： 首先对头文件的引用和创建一个结构体。这个结构体就是链表的节点，一个节点包含数据项和两个指针项，一个指针指向前一个节点的地址，另一个指针指向下一个节点的地址。DLNode* phead=NULL表示创建一个节点的指...
实现循环单链表的各种基本运算的算法
04-17
数据结构与算法 李春葆 第五版实验报告2.22 含代码和结果
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
C语言演示链表操作.rar_C语言_双向循环链表_数据结构_链表 list_链表操作
09-19
数据结构的链表关系，用TC2.0 编写，比较完整，可以作为学生的教学用
C语言 数据结构双向链表简单实例
08-31
本文主要介绍了C语言数据结构双向链表简单实例的相关知识点，包括双向链表的基本操作、删除元素、插入元素、判断对称性、排序等。 一、双向链表的基本操作 双向链表是一种数据结构，它可以在链表的任意位置插入或...
双向链表API及C语言实现
03-29
双向链表的API和C语言...另外还有线性表顺序存储、单链表、循环链表的C语言实现，文章及代码资源均已上传，可在专栏《数据结构与算法学习笔记》中查看，欢迎大家查看下载，如果内容有不合理的地方，欢迎大家批评指正。
实现循环双链表各种基本操作
weixin_63233998的博客
02-09 297
循环双链表基本操作
第四周 项目4—建设双链表算法库
fj的博客
10-05 333
1.头文件：cdlinklist.h，包含定义双链表数据结构的代码、宏定义、要实现算法的函数的声明； //循环双链表基本运算函数 typedef int ElemType; typedef struct DNode //定义双链表结点类型 { ElemType data; struct DNode *prior; //指向前驱结点 stru
循环双向链表的·插入、删除
qq_42777577的博客
11-28 736
#include"stdio.h" #include"stdlib.h" typedef int Status; typedef int ElemType; typedef struct MyStruct { ElemType data; MyStruct *prior; MyStruct *next; }*dlist,node; /* //获取指定节点地址 //位置不当是返回NULL...
C语言数据结构双向循环链表
09-27
双向循环链表是一种常用的链表结构，它与单向链表相比具有更好的灵活性和操作效率。在C语言中，实现双向循环链表需要定义一个链表节点结构体，其中包含指向前驱节点和后继节点的指针，以及存储数据的成员。以下是一个示例的C语言代码来初始化一个双向循环链表： ``` typedef int LTDataType; typedef struct ListNode { struct ListNode* next; struct ListNode* prev; LTDataType data; } LTNode; void InitDList(LTNode** pHead) { *pHead = (LTNode*)malloc(sizeof(LTNode)); (*pHead)->next = *pHead; (*pHead)->prev = *pHead; } ``` 在上述代码中，`InitDList`函数用于初始化一个双向循环链表，它使用一个头节点指针作为参数，通过动态内存分配来创建一个头节点，并将头节点的`next`和`prev`指针均指向自身，从而形成一个空的循环链表。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

殊迟

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值