数据结构之单链表的实现

最新推荐文章于 2021-12-02 20:23:59 发布
最新推荐文章于 2021-12-02 20:23:59 发布
阅读量397 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/github_33736971/article/details/51010511
版权

单链表：

特点: 链表的链接方向是单向的；
链表是由节点构成，每个节点由两部分（节点数据和指向下一节点的指针）；

>
链表的结构体及变量重定义如下：

#ifndef LIST_H_
#define LIST_H_

#define ONE  1
#define ZERO 0
#define TWO  2
//const int TRUE = 1;
//const int FALSE = 0;
enum BOOL {
    FALSE,
    TRUE
};

typedef unsigned char Boolean;

//定义连表的控制节点
typedef struct List{
    struct List_node *head;
    struct List_node *tail;
    int              count;
}List;

typedef struct List_node{
    int               data;
    struct List_node *next;
}List_node;

>
链表的常用接口如下：

List *init_list(void)                                      ;  //链表的初始化
void destroy_list(List **list)                             ;  //连表的销毁
Boolean push_front(List *list, int value)                  ;  //头部插入
Boolean push_back(List *list, int value)                   ;  //尾部插入
Boolean pop_front(List *list)                              ;  //头部删除
Boolean pop_back(List *list)                               ;  //尾部删除
void print_list(List *list)                                ;  //打印链表
void sort_list_ascend(List *list)                          ;  //升序排列连表
void sort_list_descend(List *list)                         ;  //降序
int  get_list_count(List *list)                            ;  //得到连表节点个数


List *merge_two_lists(List *list1, List *list2)            ;  //合并两个连表
List_node *find_revise_node(List *list, int num)           ;  //找到连表倒数第num个节点
List_node *find_middle_node(List *list)                    ;  //得到链表的中间节点
List *reverse_list(List *list)                             ;  //逆置链表
List *copy_list(List *list)                                ;  //链表的拷贝
Boolean is_list_intersect(List *list1, List *list2)        ;  //判断两个链表是否有交点
List_node *find_first_common_node(List *list1, List *list2);  //找到两个链表的第一个交点
void delete_one_node(List *list, List_node *node)          ;  //删除链表的一个节点
Boolean has_circle(List *list)                             ;  //判断链表是否有环
List_node *find_circle_begin(List *list)                   ;  //找到链表环的入口

链表的接口实现

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>
#include "list.h"  //""当前目录查找头文件  <>在标准库中找


static void *Malloc(size_t size);
static List_node *create_node(void);

static List_node *create_node(void)
{
    List_node *node = NULL;

    node = (List_node *)Malloc(sizeof(List_node));
    bzero(node, sizeof(List_node));

    return node;
}

static void *Malloc(size_t size)
{
    void *result = malloc(size);

    if(result == NULL){
        fprintf(stderr, "the mmemory is full!\n");
        exit(1);
    }

    return result;
}

List *init_list(void)                                        //链表的初始化
{
    List *list = NULL;
    list = (List *)Malloc(sizeof(List));
    bzero(list, sizeof(List));  //对申请的内存进行初始化（清空）

    return list;
}

void destroy_list(List **list)                               //连表的销毁
{
    //销毁步骤：（1）销毁链表节点
    //          （2）销毁控制信息
    //          （3）指针置为空
    if(list == NULL || *list == NULL){
        return ;
    }

    while((*list)->count){
        pop_front(*list);
    }

    free(*list);
    *list = NULL;
}

Boolean push_front(List *list, int value)                    //头部插入
{
    List_node *node = NULL;

    if(list == NULL){
        return FALSE;
    }

    node = create_node();
    node->data = value;

    //两种情况：1.链表数目为空
    if(list->count){
        node->next = list->head;
        list->head = node;
    }else{   //2.node既是head也是tail
        list->head = list->tail = node;
    }

    list->count++;
    return TRUE;
}

Boolean push_back(List *list, int value)                     //尾部插入
{
    List_node *node = NULL;

    if(list == NULL){
        return FALSE;
    }

    node = create_node();
    node->data = value;

    if(list->count){
        list->tail->next = node;
        list->tail = node;
    }else{
        list->head = list->tail = node;
    }

    list->count++;

    return TRUE;
}

Boolean pop_front(List *list)                                //头部删除
{
    List_node *p_node = NULL;

    if(list == NULL || list->count == ZERO){
        return FALSE;
    }

    p_node = list->head;

    if(list->count == ONE){
        list->head = list->tail = NULL;
    }else{
        list->head = p_node->next;
    }

    free(p_node);
    p_node = NULL;
    list->count--;

    return TRUE;
}

Boolean pop_back(List *list)                                 //尾部删除
{
    List_node *p_node = NULL;

    if(list == NULL || list->count == ZERO){
        return FALSE;
    }

    p_node = list->head;

    if(list->count == ONE){
        list->head = list->tail = NULL;
        free(p_node);
    }else{
        while(p_node->next != list->tail){
            p_node = p_node->next;
        }
        free(list->tail);
        list->tail = p_node;
        p_node = NULL;
    }

    list->count--;

    return TRUE;
}

void print_list(List *list)                                  //打印链表
{
    List_node *p_node = NULL;

    if(list == NULL || list->count <= ZERO){
        return ;
    }
    p_node = list->head;

    while(p_node != NULL){
        printf("%d ", p_node->data);
        p_node = p_node->next;
    }

    printf("\n");
}

static void swap(void *a, void *b, int length);
static void swap(void *a, void *b, int length)
{
    void *temp = Malloc(length);
    memcpy(temp, a, length);
    memcpy(a, b, length);
    memcpy(b, temp, length);

    free(temp);
}
void sort_list_ascend(List *list)                            //升序排列连表
{
    List_node *p_node = NULL;
    List_node *q_node = NULL;

    if(list == NULL || list->count < 2){
        return ;
    }

    for(p_node = list->head; p_node->next; p_node = p_node->next){
        for(q_node = p_node->next; q_node; q_node = q_node->next){
            if(p_node->data > q_node->data){
                 swap(&p_node->data, &q_node->data, sizeof(int));
            }
        }
    }
}

void sort_list_descend(List *list)                           //降序
{
    List_node *p_node = NULL;
    List_node *q_node = NULL;

    if(list == NULL || list->count < 2){
        return ;
    }

    for(p_node = list->head; p_node->next; p_node = p_node->next){
        for(q_node = p_node->next; q_node; q_node = q_node->next){
            if(p_node->data < q_node->data){
                 swap(&p_node->data, &q_node->data, sizeof(int));
            }
        }
    }
}

int  get_list_count(List *list)                              //得到连表节点个数
{
    if(list = NULL){
        return -1;
    }

    return list->count;
}



List *merge_two_lists(List *list1, List *list2)              //合并两个连表
{
    List *list3 = NULL;
    List_node *p_node = NULL;
    List_node *q_node = NULL;

    if(list1 == NULL && list2 == NULL){
        return list3;
    }

    list3 = init_list();

    p_node = list1->head;
    q_node = list2->head;

    while(p_node != NULL && q_node != NULL){
        if(p_node->data <= q_node->data){
            push_back(list3, p_node->data);
            p_node = p_node->next;
        }else{
            push_back(list3, q_node->data);
            q_node = q_node->next;
        }
    }

    while(p_node != NULL){
        push_back(list3, p_node->data);
        p_node = p_node->next;
    }
    while(q_node != NULL){
        push_back(list3, q_node->data);
        q_node = q_node->next;
    }

    return list3;
}

List_node *find_revise_node(List *list, int num)             //找到连表倒数第num个节点
{
    //若不知list->count,可以使用快慢指针来解决--->先让一个指针向后移动num-1步，
    //后 让另外一个指针和该指针一起向后移动，当该指针移动到末尾时即慢指针所在位
    //置即为所找节点
    #if 0
    List_node *p_node = NULL;
    int count = 0;

    if(list == NULL || num <= ZERO || list->count == ZERO
        || num > list->count){
        return NULL;
    }

    p_node = list->head;
    count = list->count - num;
    while(count--){
        p_node = p_node->next;
    }

    return p_node;
    #endif

    #if 1

    List_node *p_node = NULL;
    List_node *q_node = NULL;
    int count = 0;

    if(list == NULL || num <= ZERO){
        return NULL;
    }

    p_node = list->head;
    q_node = list->head;
    count = num - 1;

    while(count--){
        p_node = p_node->next;
    }

    while(p_node->next != NULL){
        p_node = p_node->next;
        q_node = q_node->next;
    }

    return q_node;

    #endif
}

List_node *find_middle_node(List *list)                      //得到链表的中间节点
{
    List_node *mid_node = NULL;
    int count = 0;

    if(list == NULL){
        return mid_node;
    }

    mid_node = list->head;

    count = list->count >> 1;

    while(count--){
        mid_node = mid_node->next;
    }

    return mid_node;
}

List *reverse_list(List *list)                               //逆置链表
{
    #if 0
    List *new_list = NULL;
    List_node *p_node = NULL;
   // List_node *q_node = NULL;

    if(list == NULL || list->count <= ONE){
        return new_list;
    }

    p_node = list->head;
    new_list = init_list();
    //q_node = new_list->head;

    while(p_node != NULL){
        push_front(new_list, p_node->data);
        p_node = p_node->next;
    }

    return new_list;
    #endif

    #if 1

    List_node *p_node = NULL;
    List_node *q_node = NULL;
    List_node *r_node = NULL;

    if(list == NULL || list->count <= ONE){
        return list;
    }

    if(list->count == TWO){
        list->tail->next = list->head;
        list->head->next = NULL;
    }else{
        p_node = list->head;
        q_node = p_node->next;
        r_node = q_node->next;
        p_node->next = NULL;
        do{
            q_node->next = p_node;    
            p_node = q_node;
            q_node = r_node;
            r_node = r_node->next;
        }while(r_node != NULL);
        q_node->next = p_node;
    }

    swap(&list->head, &list->tail, sizeof(List_node *));
    return list;
    #endif
}

List *copy_list(List *list)                                  //链表的拷贝
{
    List *result = NULL;
    List_node *p_node = NULL;

    if(list == NULL){
        return NULL;
    }

    result = init_list();
    p_node = list->head;

    while(p_node != NULL){
        push_back(result, p_node->data);
        p_node = p_node->next;
    }

    return result;
}

Boolean is_list_intersect(List *list1, List *list2)          //判断两个链表是否有交点
{
    if(list1 == NULL || list2 == NULL || list1->count == ZERO
        || list2->count == ZERO){
        return FALSE;
    }

    return list1->tail == list2->tail;

#if 0
    if(list1->tail == list2->tail){
        return TRUE;
    }else{
        return FALSE;
    }
#endif
}

List_node *find_first_common_node(List *list1, List *list2)  //找到两个链表的第一个交点
{
    int len = 0;
    int l1_len = 0;
    int l2_len = 0;
    List_node *p_node = NULL;
    List_node *q_node = NULL;

    if(list1 == NULL || list2 == NULL || list1->count == ZERO 
        || list2->count == ZERO || is_list_intersect == FALSE){
        return NULL;
    }

    l1_len = list1->count;
    l2_len = list2->count;
    p_node = list1->head;
    q_node = list2->head;

    if(l1_len >= l2_len){
        len = l1_len - l2_len;
        while(len--){
            p_node = p_node->next;
        }
    }else{
        len = l2_len - l1_len;
        while(len--){
            q_node = q_node->next;
        }
    }

    while(p_node != q_node){
        p_node = p_node->next;
        q_node = q_node->next;
    }

    return p_node;
}

void delete_one_node(List *list, List_node *node)            //删除链表的一个节点
{
    //用node的next的data覆盖node的data，并让node的next指向其next的next
    //然后将node的next删除
    List_node *p_node = NULL;

    if(list == NULL || node == NULL){
        return ;
    }

    p_node = list->head;

    if(node->next != NULL){
        p_node = node->next;
        node->data = p_node->data;
        node->next = p_node->next;      
        free(p_node);
        list->count--;
    }else{
        pop_back(list);
    }
}

Boolean has_circle(List *list)                               //判断链表是否有环
{
    List_node *p_node = NULL;

    if(list == NULL || list->count < TWO || list->tail->next == NULL){
        return FALSE;
    }

    p_node = list->head;
    while(p_node != NULL){
        if(p_node == list->tail->next){
            return TRUE;
        }
        p_node = p_node->next;
    }   

    return FALSE;
}

Boolean has_circle2(List *list, List_node **intersect);
Boolean has_circle2(List *list, List_node **intersect)
{
    List_node *p_node = NULL;
    List_node *q_node = NULL;

    if(list == NULL || list->count < TWO){
        return FALSE;
    }

    p_node = q_node = list->head;

    while(q_node != NULL && q_node->next != NULL){
        p_node = p_node->next;
        q_node = q_node->next->next;

        if(p_node == q_node){

            return TRUE;
        }
    }

    return FALSE;
}

//如果函数有多个返回值，只有传入某个值指针类型，才可以将其传出
List_node *find_circle_begin(List *list)                     //找到链表环的入口
{
    List_node *p_node = NULL;

    if(list == NULL || list->count < TWO || list->tail->next == NULL){
        return NULL;
    }

    p_node = list->head;

    do{
        if(p_node == list->tail->next){
            return p_node;
        }
        p_node = p_node->next;
    }while(p_node != NULL);

    return NULL;
}

List_node *find_circle_begin2(List *list);                     //找到链表环的入口
List_node *find_circle_begin2(List *list)                     //找到链表环的入口
{
    if(!has_circle2(list, &intersect)){
        return NULL;
    }
}

链表的测试代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include "list.h"

int main(int ac, char **av)
{
    List *list = init_list();  //链表初始化
    List *list1 = init_list();
    List *list2 = init_list();
    List *list3 = NULL;
    List_node *p_node = NULL;
    List_node *q_node = NULL;
    int i = 0;
    int result = 0;
    srand(time(NULL));

    for(i = 0; i < 10; ++i){
        push_front(list, rand() % 100);
    }

    for(i = 0; i < 10; ++i){
        push_front(list1, rand() % 100);
    }

    printf("before sort show list:\n");
    print_list(list);
    printf("before sort show list1:\n");
    print_list(list1);
    sort_list_ascend(list);
    sort_list_ascend(list1);
    printf("after sort show list:\n");
    print_list(list);
    printf("after sort show list1:\n");
    print_list(list1);
    list2 = merge_two_lists(list, list1); 
    printf("after merge show list2:\n");
    print_list(list2);
    printf("after merge show list:\n");
    print_list(list);
    printf("after merge show list1:\n");
    print_list(list1);
    printf("after reverse show list2:\n");
    list3 = reverse_list(list2);
    printf("after reverse show list3:\n");
    print_list(list3);
    printf("倒数第num个节点\n");
    p_node = find_revise_node(list3, 5);
    printf("%d\n", p_node->data);
    //printf("中间节点\n");
    //printf("删除一个节点\n");
    //delete_one_node(list, );
    //print_list(list);

    printf("判断两个链表是否有交点\n");
    result = is_list_intersect(list, list1);
    printf("result is : %d\n", result);
    q_node = find_first_common_node(list, list1);
    printf("%d\n", p_node->data);

    sort_list_descend(list);
    print_list(list);

    destroy_list(&list);   //链表的销毁
    destroy_list(&list1);   //链表的销毁
    destroy_list(&list2);   //链表的销毁

    return 0;
}

测试结果如下：

[root@localhost list]# ./main 
before sort show list:
75 68 13 10 17 45 10 24 60 21 
before sort show list1:
43 8 32 88 52 8 51 87 36 20 
after sort show list:
10 10 13 17 21 24 45 60 68 75 
after sort show list1:
8 8 20 32 36 43 51 52 87 88 
after merge show list2:
8 8 10 10 13 17 20 21 24 32 36 43 45 51 52 60 68 75 87 88 
after merge show list:
10 10 13 17 21 24 45 60 68 75 
after merge show list1:
8 8 20 32 36 43 51 52 87 88 
after reverse show list2:
after reverse show list3:
88 87 75 68 60 52 51 45 43 36 32 24 21 20 17 13 10 10 8 8 
倒数第num个节点
13
判断两个链表是否有交点
result is : 0
13
75 68 60 45 24 21 17 13 10 10 
[root@localhost list]#
lm_123_456
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解：寻找两个链表的交点
weixin_50394543的博客
03-20 2552
详解：寻找两个链表的交点
单链表-C++数据结构之单链表实现.zip
最新发布
03-13
单链表是计算机科学中一种基础且重要的数据结构，它在C++中有着广泛的应用。在C++中实现单链表，需要理解链表的基本概念、节点结构以及相关的操作。以下是对这一主题的详细讲解： 1. **链表概念**： 链表是一种...
链表 - 判断两个链表是否有交点
yonggandess的博客
12-02 545
原地址 解题思路 定义双指针，分别指向A和B的头部。 如果链表一样长且有交点，则第一次遍历就能找到相同交点，返回 如果不一样长且有交点，则指针遍历一条链表后，遍历另一条链表 如：A链表的指针遍历完A了，下一步继续遍历B链表。B链表的指针遍历完B了，下一步继续遍历A链表。 如图所示，由于a+c+b=b+c+a，所以两个指针在第二次遍历的时候，一定会在相交节点处相遇。 如果没有交点，则第二次遍历结束都是null，遍历结束，返回null a+b=b+a，最终一定都会指向null。 ..
判断链表是否有交点（是否有环）
金金金金金的博客
03-15 200
//判断两个链表是有交点 typedef int DataType; struct ListNode{ DataType val; struct ListNode* next; }; typedef ListNode Node; //带环：两个链表都带环 //不带环：两个链表都不带环 //1.先判断两个链表是否带环 //利用快慢指针判断链表是否有环 Node* hasCirc...
<笔试><面试>C/C++单链表相关（4）判断两链表是否相交，求交点（链表不带环/可能带环）...
weixin_33696106的博客
01-21 105
判断两链表是否相交，求交点（假设链表不带环）判断两链表是否相交，求交点（假设链表可能带环）RingEntry_Point()等函数见前篇.SListNode*Intersect(SListNode*&L,SListNode*&M)//判断两链表是否相交，求交点（假设链表不带环） { //思路：若不带环，只有相交/不想交两种情况 //与RingEn...
如何判断两个链表是否有交点
weixin_40304276的博客
09-27 1052
如何判断两个链表是否有交点 首先，两个链表如果有交点它应该是y型的。 分别遍历两个链表，如果尾节点地址相同，则有交点 分别遍历两个链表，计算两链表长度，长的为A，短的为B，让长的链表先走A-B步，然后两个链表仪器走，走到同一地址处为交点。 把两个链表压到两个栈里，分别将栈顶弹出，比较，知道弹出的地址不同，则上一个弹出的为交点。 把两个链表放到两个数组中遍历，地址相同为交点。   如何判...
C++数据结构之单链表实现
09-18
单链表是一种线性数据结构，其中每个元素（称为节点）包含两部分：数据域和指针域。数据域存储实际的数据，而指针域指向下一个节点。链表的最后一个节点的指针域通常为NULL，表示链表的结束。 接下来，我们将通过...
数据结构之单链表实现
12-10
在“数据结构之单链表实现”的主题中，我们将关注以下几个核心知识点： 1. **链表的创建**：首先，我们需要定义一个结构体来表示链表节点，通常包括数据字段和指向下一个节点的指针。然后，我们可以通过创建头节点...
使用C++实现链表数据结构之单链表.zip
03-13
总的来说，理解和实现链表数据结构是学习数据结构和算法的基础，而C++提供了强大的工具来实现这些抽象概念。单链表是链表的一个简单但实用的形式，它能帮助你理解更复杂链表结构，如双向链表和循环链表。通过实践...
数据结构单链表c语言实现
03-26
数据结构的单链表C语言版完整实现，本人知识初学者实力浅浅，可能对于大佬来说只是rubb**。如果同样是初学者的话，可能对于你或许有些用处。如果帮助到你很开心，如果你觉得有些low希望可以提出宝贵的建议 ！！
判断链表是否相交并找出交点
Bryant5051的博客
03-09 218
问题概述 单链表定义如下： public class ListNode { int val; ListNode next; ListNode(int x) { val = x; next = null; } } 编写程序， 找出两个链表的交点。 如图所示，链表 A 和链表 B 在节点 8 处相交。 算法思路 首先确定一个事情： 如果两个链表有交点， 那么这两个链表的尾节点一定是相等的。 现在不仅需要判断是否有
两个单链表相交的问题
dezhewei9015的博客
04-28 144
单链表可能有环无环； 给定两个 单链表的头节点 head1和head2，这两个链表可能相交，也可能 不相交。请实现一个函数， 如果两个链表相交，请返回相交的 第一个节点；如果不相交，返回null 即可。 链表长度分别为 N M， 时间复杂度O（N + M）；额外空间 O（1） ； 1 package my_basic.class_3; 2 3 publi...
链表的交点问题
天涯海角
06-24 1721
单链表交点问题的分类： a.两个链表都无环  b.两个链表都有环（交点在环外；交点在环内） 下边给出图示：                      注意：两个链表的交点处，并不仅仅是data域相等，还要有next域相同。 如果一个链表有环，另一个链表无环，他们是不可能有交点的。 反证：如果有交点，一个链表有环，另一个链表必然有环。不符合条件。 从以上可以看出，要想完全弄清
循环链表相交-快慢指针找相交点证明
qq1187239259的博客
06-18 600
我们要证明的不是 b = c， 而是两个速度相同的指针分别从O点和P点顺时针出发，它们会在Q点相遇。 1、 先行条件是快慢指针在P点相遇，且快指针速度是慢指针的2倍，则相遇时，快指针走过的路径长度是慢指针的2倍 解： 设快慢指针在P点相遇时，慢指针在圆圈中走了m圈， 快指针走了n圈。 则有： 2[c + m(a + b) + a] = c + n(a + b) + a (1) ...
判断两个链表是否相交并找出交点，判断一个链表是否有环
qichangjian的博客
02-28 1593
链表的分类 链表主要分为三类： 单向链表只能从表头到表尾的顺序，每个节点中保存了指向下一个节点的指针； 双向链表则可以反向遍历，因为节点中既保存了向后节点的指针，又保存了向前节点的指针。 循环链表指的是在单向链表和双向链表的基础上，将两种链表的最后一个结点指向第一个结点从而实现循环。 判断两个链表是否相交并找出交点 问题描述： 一个比较经典的问题，判断两个链表是否相交，如果相交找出他们的交点。 解...
判断两个链表是否相交并找出交点-笔记
renwotao2009的专栏
04-12 3275
判断两个链表是否相交的方法 相交链表的特征：如果两个链表相交，那么交点以后的节点都相同，否则不相交。1 暴力搜索法这个地球人都懂得2 节点hash法两个链表的节点进行hash，然后判断节点hash值和节点的值是否相等来判断。 不推荐这样做，每个节点进行hash，然后判断，程序上比较累赘。若要实现，可以参考Java中HashMap的源码实现。3 链表衔接法一个链表的尾部连接下一个链表的头部，通过判
判断单链表是否有环
热门推荐
茄子的专栏
07-12 2万+
1、如何判断一个链表是不是这类链表？　 2、如果链表为存在环，如果找到环的入口点？解答：一、判断链表是否存在环，办法为：设置两个指针(fast, slow)，初始值都指向头，slow每次前进一步，fast每次前进二步，如果链表存在环，则fast必定先进入环，而slow后进入环，两个指针必定相遇。(当然，fast先行头到尾部为NULL，则为无环链表)程序如下：bool IsExi
php spl 链表,GitHub - peng456/php_spl: 单链表、双向链表 等PHP。已经实现了。
weixin_31067983的博客
03-10 99
php_spl单链表、双向链表 等PHP。已经实现了。SPLStand PHP Library。SPL是用于解决典型问题(standard problems)的一组接口与类的集合。比如那些经典数据结构，面试中常会文档的问题。SPL 已经给你，准备了。当然工作过程中也会用到。但是不会那么频繁。安装啊，配置啥，应该不用考虑，PHP5 都已经内置了。忽然想起来，我以前看过。但是没啥印象了呢。看来程序员...
数据结构：单链表与结点实现解析
"数据结构第一二章课件涵盖了单链表、结点的C语言描述以及单链表操作的实现等内容，讲解了线性表的链式表示和存储结构。" 在数据结构中，线性表是一种基本的数据组织形式，由有限个相同类型元素构成的有序序列。在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值