SDUT— 程序设计基础II-实验2 链表

已于 2023-03-24 20:53:27 修改
阅读量229 收藏 6
点赞数 1
文章标签： 数据结构 链表 算法
于 2023-03-15 19:11:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73724322/article/details/129564330
版权

 数据结构实验之链表一：顺序建立链表

输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。

输入格式:

第一行输入整数的个数N(1 <= N <= 100000)。

第二行依次输入每个整数。

输出格式:

输出这组整数。

输入样例:

8
12 56 4 6 55 15 33 62

输出样例:

12 56 4 6 55 15 33 62
#include <stdio.h>
#include <stdlib.h>
struct node
{
    int data;
    struct node * next;
};
struct node * creat(int);
void output(struct node *head);
int main()
{
    int N;
    struct node *head;
    scanf("%d", &N);
    head = creat(N);
    output(head);
    return 0;
}
struct node * creat(int n)
{
    int i;
    struct node *head, *tail, *p;
    head = (struct node *)malloc(sizeof(struct node));
    head->next = NULL;
    tail = head;
    for(i = 1; i <= n; i++)
    {
        p = (struct node *)malloc(sizeof(struct node));
        p->next = NULL;
        scanf("%d", &p->data);
        tail->next = p;
        tail = p;
    }
    return head;
};
void output(struct node*head )
{
    struct node *p;
    p = head->next;
 
    while(p != NULL)
    {
        if(p == head->next)  printf("%d", p->data);
    
        else  printf(" %d", p->data);
        p = p->next;
    }
    printf("\n");
}

 数据结构实验之链表二：逆序建立链表

 

输入整数个数N，再输入N个整数，按照这些整数输入的相反顺序建立单链表，并依次遍历输出单链表的数据。

输入格式:

第一行输入整数N（1<=N<=100000)。

第二行依次输入N个整数，逆序建立单链表。

输出格式:

依次输出单链表所存放的数据。

输入样例:

10
11 3 5 27 9 12 43 16 84 22

输出样例:

22 84 16 43 12 9 27 5 3 11
#include <stdio.h>
#include <stdlib.h>
struct node
{
	int data;
	struct node* next;
};
int main()
{
	int i, n;
	struct node* head, * p;
	head = (struct node*)malloc(sizeof(struct node));
	head->next = NULL;
	scanf("%d", &n);
	for (i = 0; i < n; i++)
	{
		p = (struct node*)malloc(sizeof(struct node));
		scanf("%d",& p->data);
		p->next = head->next;
		head->next = p;
	}	
	while (p!=NULL)
	{
		if (p->next!=NULL)
		{
			printf("%d ", p->data);
		}
		else
		{
			printf("%d\n", p->data);
		}
		p = p->next;
	}
}

 数据结构实验之链表三：链表的逆置

 

输入多个整数，以-1作为结束标志，顺序建立一个带头结点的单链表，之后对该单链表的数据进行逆置，并输出逆置后的单链表数据。

输入格式:

输入多个整数，以-1作为结束标志。（整数个数不超过100000，不低于1）

输出格式:

输出逆置后的单链表数据。

输入样例:

12 56 4 6 55 15 33 62 -1

输出样例:

62 33 15 55 6 4 56 12
#include<stdio.h>
#include<stdlib.h>
typedef struct NODE
{
    int data;
    struct NODE *next;
}Node;
int main()
{
    Node *head,*p;
    int num;
    head=(Node*)malloc(sizeof(Node));
    head->next=NULL;
    while(scanf("%d",&num)&&num!=-1)
    {
        p=(Node*)malloc(sizeof(Node));
        p->next=NULL;
        p->data=num;
        p->next=head->next;
        head->next=p;
    }
   while (p!=NULL)
	{
		if (p->next!=NULL)
		{
			printf("%d ", p->data);
		}
		else
		{
			printf("%d\n", p->data);
		}
		p = p->next;
	}
    return 0;
}

 数据结构实验之链表四：有序链表的归并

分别输入两个有序的整数序列（分别包含M和N个数据），建立两个有序的单链表，将这两个有序单链表合并成为一个大的有序单链表，并依次输出合并后的单链表数据。

输入格式:

第一行输入M与N的值。(1 <= M <=100000, 1 <= N <= 100000)

第二行依次输入M个有序的整数。

第三行依次输入N个有序的整数。

输出格式:

输出合并后的单链表所包含的M+N个有序的整数。

输入样例:

6 5
1 23 26 45 66 99
14 21 28 50 100

输出样例:

1 14 21 23 26 28 45 50 66 99 100
#include<stdio.h>
#include<stdlib.h>
struct node
{
    int data;
    struct node *next;
};
struct node *together(struct node *head1,struct node *head2)
{
    struct node *p1,*p2,*tail;
    p1=head1->next;
    p2=head2->next;
    tail=(head1);
    free(head2);
    while(p1!=NULL&&p2!=NULL)
    {
        if(p1->data<p2->data)
        {
            tail->next=p1;
            tail=p1;
            p1=p1->next;
        }
        else
        {
            tail->next=p2;
            tail=p2;
            p2=p2->next;
        }
    }
    if(p1!=NULL)
        tail->next=p1;
    else
        tail->next=p2;
        return head1;
};
int main()
{
    int m,n,i;
    struct node *head1,*head2,*q1,*q2,*p1,*p2,*p;
    head1=(struct node*)malloc(sizeof(struct node));
    head2=(struct node*)malloc(sizeof(struct node));
    q1=head1;
    q2=head2;
    head1->next=NULL;
    head2->next=NULL;
    scanf("%d%d",&m,&n);
    for(i=0;i<m;i++)
    {
        p1=(struct node*)malloc(sizeof(struct node));
        scanf("%d",&p1->data);
        p1->next=NULL;
        q1->next=p1;
        q1=p1;
    }
    for(i=0;i<n;i++)
    {
        p2=(struct node*)malloc(sizeof(struct node));
        scanf("%d",&p2->data);
        p2->next=NULL;
        q2->next=p2;
        q2=p2;
    }
    p=together(head1,head2);
    p=p->next;
    for(i=0;i<m+n;i++)
    {
        if(i==m+n-1)
            printf("%d\n",p->data);
        else
            printf("%d ",p->data);
        p=p->next;
    }
    return 0;
}

数据结构实验之链表五：单链表的拆分

输入N个整数顺序建立一个单链表，将该单链表拆分成两个子链表，第一个子链表存放了所有的偶数，第二个子链表存放了所有的奇数。两个子链表中数据的相对次序与原链表一致。

输入格式:

第一行输入整数N（1<=N<=100000)。

第二行依次输入N个整数。 （保证奇数偶数都存在）

输出格式:

第一行分别输出偶数链表与奇数链表的元素个数；

第二行依次输出偶数子链表的所有数据；

第三行依次输出奇数子链表的所有数据。

输入样例:

10
1 3 22 8 15 999 9 44 6 1001

输出样例:

4 6
22 8 44 6
1 3 15 999 9 1001

#include <stdio.h>
#include <stdlib.h>
struct node
{
    int data;
    struct node *next;
};
int main()
{
    int i,n,j=0,k=0;
    struct node *head,*head1,*head2,*p,*p1,*p2,*t,*t1,*t2;
    scanf("%d",&n);
    head=(struct node*)malloc(sizeof(struct node));
    head->next=NULL;
    t=head;
    for(i=0;i<n;i++)
    {
        p=(struct node*)malloc(sizeof(struct node));
        scanf("%d",&p->data);
        p->next=NULL;
        t->next=p;
        t=p;
    }
    head1=(struct node*)malloc(sizeof(struct node));
    head1->next=NULL;
    t1=head1;
    head2=(struct node*)malloc(sizeof(struct node));
    head2->next=NULL;
    t2=head2;
    p=head->next;
    while(p)
    {
        if(p->data%2==0)
        {
            p1=(struct node*)malloc(sizeof(struct node));
            p1->data=p->data;
            p1->next=NULL;
            t1->next=p1;
            t1=p1;
            j++;
        }
        else
        {
            p2=(struct node*)malloc(sizeof(struct node));
            p2->data=p->data;
            p2->next=NULL;
            t2->next=p2;
            t2=p2;
            k++;
        }
        p=p->next;
    }
    printf("%d %d\n",j,k);
    p1=head1->next;
    while(j--)
    {
        if(j==0)
            printf("%d\n",p1->data);
        else
            printf("%d ",p1->data);
        p1=p1->next;
    }
    p2=head2->next;
    while(k--)
    {
        if(k==0)
            printf("%d\n",p2->data);
        else
            printf("%d ",p2->data);
        p2=p2->next;
    }
    free(p);
    free(p1);
    free(p2);
    return 0;
}

数据结构实验之链表七：单链表中重复元素的删除

按照数据输入的相反顺序（逆位序）建立一个单链表，并将单链表中重复的元素删除（值相同的元素只保留最后输入的一个）。

输入格式:

第一行输入元素个数 n (1 <= n <= 15)；

第二行输入 n 个整数，保证在 int 范围内。

输出格式:

第一行输出初始链表元素个数；

第二行输出按照逆位序所建立的初始链表；

第三行输出删除重复元素后的单链表元素个数；

第四行输出删除重复元素后的单链表。

输入样例:

10
21 30 14 55 32 63 11 30 55 30

输出样例:

#include<stdio.h>
#include<stdlib.h>
struct node
{
    int data;
    struct node *next;
};
int main()
{
    struct node *head,*p,*q,*t;
    head=(struct node *)malloc(sizeof(struct node));
    head->next=NULL;
    int i,n;
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        q=(struct node *)malloc(sizeof(struct node));
        scanf("%d",&q->data);
        q->next=head->next;
        head->next=q;
    }
    printf("%d\n",n);
    q=head->next;
    while(q)
    {
        if(q->next==NULL)
            printf("%d\n",q->data);
        else printf("%d ",q->data);
        q=q->next;
    }
    q=head->next;
    while(q)
    {
        p=q;
        t=q->next;
        while(t)
        {
            if(t->data==q->data)
            {
                p->next=t->next;
                free(t);
                t=p->next;
                n--;
            }
            else
            {
                p=t;
                t=t->next;
            }
        }
        q=q->next;
    }
    printf("%d\n",n);
    q=head->next;
    while(q)
    {
        if(q->next==NULL)
            printf("%d\n",q->data);
        else printf("%d ",q->data);
        q=q->next;
    }
    return 0;
}


10
30 55 30 11 63 32 55 14 30 21
7
30 55 11 63 32 14 21

师--链表的结点插入

给出一个只有头指针的链表和 n 次操作，每次操作为在链表的第 m 个元素后面插入一个新元素x。若m 大于链表的元素总数则将x放在链表的最后。

输入格式:

多组输入。

每组数据首先输入一个整数n(1<=n<=100)，代表有n次操作。

接下来的n行，每行有两个整数Mi(0<=Mi<=10000)，Xi。

输出格式:

对于每组数据。从前到后输出链表的所有元素,两个元素之间用空格隔开。

输入样例:

4
1 1
1 2
0 3
100 4

输出样例:

3 1 2 4

#include<stdio.h>
#include<stdlib.h>
struct node
{
    int data;
    struct node *next;
};
int main()
{
    int n,m,x;
    struct node *head,*p,*q;
    while(~scanf("%d",&n))
    {
        head=(struct node *)malloc(sizeof(struct node));
        head->next=NULL;
        while(n--)
        {
            q=head;
            scanf("%d %d",&m,&x);
            while(m--&&q->next)
                q=q->next;
            p=(struct node *)malloc(sizeof(struct node));
            p->data=x;
            p->next=NULL;
            p->next=q->next;
            q->next=p;
        }
        q=head->next;
        while(q)
        {
            if(q->next==NULL) printf("%d\n",q->data);
            else printf("%d ",q->data);
            q=q->next;
        }
    }
    return 0;
}

约瑟夫问题

n个人想玩残酷的死亡游戏，游戏规则如下：

n个人进行编号，分别从1到n，排成一个圈，顺时针从1开始数到m，数到m的人被杀，剩下的人继续游戏，活到最后的一个人是胜利者。

请输出最后一个人的编号。

输入格式:

输入n和m值。 (1<=n<=100 , 1<=m<=100)

输出格式:

输出胜利者的编号。

输入样例:

5 3

输出样例:

4

#include<stdio.h>
#include<stdlib.h>
struct node
{
    int data;
    struct node *next;
};
int main()
{
    struct node *head,*p,*q,*tail;
    int n,i,m,num;
    head=(struct node *)malloc(sizeof(struct node));
    head->data=-1;
    head->next=NULL;
    tail=head;
    scanf("%d %d",&n,&m);
    for(i=0;i<n;i++)
    {
        p=(struct node*)malloc(sizeof(struct node));
       p->data=i+1;
        p->next=NULL;
        tail->next=p;
        tail=p;
        p->next=head->next;
        
        
    }p=head->next;
    q=tail;
    i=1;
    while(q!=p)
    {
        if(i==m)
        {
            q->next=p->next;
            free(p);
            p=q->next;
            i=1;
        }
        else
        {
            q=p;
            p=p->next;
            i++;
        }
    }
    num=p->data;
    free(p);
    head->next=NULL;
    printf("%d",num);
    return 0;
    
}

数据结构实验之链表九：双向链表

学会了单向链表，我们又多了一种解决问题的能力，单链表利用一个指针就能在内存中找到下一个位置，这是一个不会轻易断裂的链。但单链表有一个弱点——不能回指。比如在链表中有两个节点A,B，他们的关系是B是A的后继，A指向了B，便能轻易经A找到B,但从B却不能找到A。一个简单的想法便能轻易解决这个问题——建立双向链表。在双向链表中，A有一个指针指向了节点B，同时，B又有一个指向A的指针。这样不仅能从链表头节点的位置遍历整个链表所有节点，也能从链表尾节点开始遍历所有节点。对于给定的一列数据，按照给定的顺序建立双向链表，按照关键字找到相应节点，输出此节点的前驱节点关键字及后继节点关键字。

输入格式:

第一行两个正整数n（代表节点个数），m（代表要找的关键字的个数）。第二行是n个数（n个数没有重复），利用这n个数建立双向链表。接下来有m个关键字，每个占一行。(1<=n<=50)

输出格式:

对给定的每个关键字，输出此关键字前驱节点关键字和后继节点关键字。如果给定的关键字没有前驱或者后继，则不输出。

注意：每个给定关键字的输出占一行。
一行输出的数据之间有一个空格，行首、行末无空格。

输入样例:

10 3
1 2 3 4 5 6 7 8 9 0
3
5
0

输出样例:

2 4
4 6
9
#include <stdio.h>
#include <stdlib.h>
struct node
{
    int data;
    struct node* next, * before;
};

struct node* Creat(int n)
{
    int i;
    struct node* p, * head, * tail;
    head = (struct node*)malloc(sizeof(struct node));
    head->next = NULL;
    head->before = NULL;
    tail = head;
    for (i = 0; i < n; i++)
    {
        p = (struct node*)malloc(sizeof(struct node));
        p->next = NULL;
        p->before = NULL;
        scanf("%d", &p->data);
        tail->next = p;
        p->before = tail;
        tail = p;
    }
    return head;
}

int main()
{
    int n, m, t;
    scanf("%d %d", &n, &m);
    struct node* head, * p;
    head = Creat(n);
    while (m--)
    {
        scanf("%d", &t);
        p = head->next;
        while (p)
        {
            if (p->data == t)
            {
                if (p->next && p->before != head)
                {
                    printf("%d %d\n", p->before->data, p->next->data);
                    break;
                }
                else if (p->next)
                {
                    printf("%d\n", p->next->data);
                    break;
                }
                else
                {
                    printf("%d\n", p->before->data);
                    break;
                }
            }
            else
                p = p->next;
        }
    }
    return 0;
}

 不敢死队问题

说到“敢死队”，大家不要以为我来介绍电影了，因为数据结构里真有这么道程序设计题目，原题如下：

有M个敢死队员要炸掉敌人的一个碉堡，谁都不想去，排长决定用轮回数数的办法来决定哪个战士去执行任务。如果前一个战士没完成任务，则要再派一个战士上去。现给每个战士编一个号，大家围坐成一圈，随便从某一个战士开始计数，当数到5时，对应的战士就去执行任务，且此战士不再参加下一轮计数。如果此战士没完成任务，再从下一个战士开始数数，被数到第5时，此战士接着去执行任务。以此类推，直到任务完成为止。

这题本来就叫“敢死队”。“谁都不想去”，就这一句我觉得这个问题也只能叫“不敢死队问题”。今天大家就要完成这道不敢死队问题。我们假设排长是1号，按照上面介绍，从一号开始数，数到5的那名战士去执行任务，那么排长是第几个去执行任务的？

输入格式:

输入包括多组数据，每行一个整数M（0<=M<=10000)（敢死队人数），若M=0，输入结束，不做处理。

输出格式:

输出一个整数n，代表排长是第n个去执行任务。

输入样例:

9
6
223
0

输出样例:

2
6
132
#include<stdio.h>
#include<stdlib.h>
struct node
{
    int data;
    struct node *next;
};
int main()
{
    int n,num,i,m;
    struct node *head,*tail,*p;
    while(scanf("%d",&n)!=EOF&&n!=0)
    {
        head=(struct node *)malloc(sizeof(struct node));
        head->next=NULL;
        tail=head;
        for(i=1;i<=n;i++)
        {
            p=(struct node *)malloc(sizeof(struct node));
            p->data=i;
            p->next=NULL;
            tail->next=p;
            p->next=head->next;
            tail=p;
        }
      
        num=0;
        m=0;
       
        p=head->next;
        while(num<n)
        {
            m++;
            if(m%5==0)
            {
                num++;
                tail->next=p->next;
                if(p->data==1)
                    break;
                tail->next=p->next;
                free(p);
                p=tail->next;
            }
            else
            {
                tail=p;
                p=p->next;
            }
        }
        printf("%d\n",num);
    }
    return 0;
}

阿东*
关注
山东理工大学-2022级-程序设计基础I-实验4 循环结构之for语句
m0_72900498的博客
11-06 666
山东理工大学-2022级-程序设计基础I-实验4 循环结构之for语句-----一题多解
SDUT 《程序设计基础I 》实验2-选择结构程序 知识点+题目详解
m0_72900498的博客
11-07 500
SDUT 《程序设计基础I 》实验2-选择结构程序 设计题解 && c语言语法讲解（一题多解）
程序设计基础II-实验2-链表-7-10 不敢死队问题
m0_73688552的博客
12-29 303
说到“敢死队”，大家不要以为我来介绍电影了，因为数据结构里真有这么道程序设计题目，原题如下：有M个敢死队员要炸掉敌人的一个碉堡，谁都不想去，排长决定用轮回数数的办法来决定哪个战士去执行任务。如果前一个战士没完成任务，则要再派一个战士上去。现给每个战士编一个号，大家围坐成一圈，随便从某一个战士开始计数，当数到5时，对应的战士就去执行任务，且此战士不再参加下一轮计数。如果此战士没完成任务，再从下一个战士开始数数，被数到第5时，此战士接着去执行任务。以此类推，直到任务完成为止。这题本来就叫“敢死队”。
SDUT 2019 级程序设计基础（B）II 实验2--链表
Here_SDUT的博客
06-03 799
快期末了 好久没用过C，重新打一下程设二的内容找找手感，顺便水几篇博客，简单题直接过，需要思考的会有注释或者思路，重要知识点会总结，祝大家期末都AK！！！ 总题目链接 2-1数据结构实验之链表一：顺序建立链表 #include <stdio.h> #include <stdlib.h> typedef struct//使用typedef后，之后定义该类型结构体不用写struct node p，直接node p即可，后面不解释 { int data; struct n
SDUT---OJ《程序设计基础（B）II》实验2--链表
m0_46062697的博客
11-06 1711
A - 数据结构实验之链表一：顺序建立链表 Description 输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。 Input 第一行输入整数的个数N； 第二行依次输入每个整数。 Output 输出这组整数。 Sample Input 8 12 56 4 6 55 15 33 62 Output 12 56 4 6 55 15 33 62 #include<stdio.h> #include<stdlib.h> st..
SDUT 《程序设计基础（B）II》实验2--链表
sdut_you的博客
06-08 323
2019级《程序设计基础（B）II》实验2–链表 https://acm.sdut.edu.cn/onlinejudge3/contests/3193/overview A - 数据结构实验之链表一：顺序建立链表 #include <stdio.h> #include <stdlib.h> #include <string.h> struct node { int data; struct node *next; }; int main() { s
山东理工大学-2022级-程序设计基础I-实验2 选择结构 7-5sdut-C语言实验——找中间数
weixin_73751948的博客
10-14 840
输入三个整数，找出其中的中间数。（这里的中间数指的是大小，不是位置。）输入格式:输入3个整数。
sdut stm32&mdk-arm单片机期末实验
06-30
sdut stm32&mdk-arm单片机期末实验
详解：冒泡排序
最新发布
2401_83418369的博客
09-14 748
冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
数据结构--树
wxdzuishaui的博客
09-14 137
【代码】数据结构--树。
【数据结构和算法实践-树-LeetCode113-路径总和Ⅱ】
Mao_c的博客
09-14 338
leetcode b树
数据库索引底层数据结构之B+树&MySQL中的页&索引分类【纯理论干货，面试必备】
2401_83595513的博客
09-14 1162
数据库中的索引，其底层数据结构及分类。
从零开始学数据结构系列之第六章《希尔排序》
铁匠匠匠的博客
09-14 547
​ 希尔排序是对插入排序的优化，基本思路是先选定一个整数作为增量，把待排序文件中的所有数据分组，以每个距离的等差数列为一组，对每一组进行排序，然后将增量缩小，继续分组排序，重复上述动作，直到增量缩小为1时，排序完正好有序。​ 我们发现，当被排序的对象越接近有序时，插入排序的效率越高，那我们是否有办法将数组变成接近有序后再用插入排序，此时希尔大佬就发现了这个排序算法，并命名为希尔排序。逆序有序的数组排序时，时间复杂度为O ( n 2 ) O(n^2)O(n 2)，此时效率最低。如果是最开始的分组方法的话。
【Python】数据结构,链表,算法详解
2201_75415080的博客
09-09 1729
自定义代码-模拟链表删除节点查找节点算法入门-排序类的冒泡排序选择排序插入排序快速排序算法入门-查找类的二分查找-递归版二分查找-非递归版分线性结构-树介绍基本概述特点和分类自定义代码-模拟二叉树"""案例: 自定义代码, 模拟链表.​背景:顺序表在存储数据的时候, 需要使用到连续的空间, 如果空间不够, 就会导致扩容失败, 针对于这种情况, 我们可以通过链表实现.链表在内存中存储的时候, 可以不是连续的空间, "有地儿就行", 所以: 增删相对更好操作.​。
C 408—《数据结构》算法题基础篇—链表（上）
Cyan_RA9的博客
09-09 948
408考研——《数据结构》算法题基础篇之链表（上）。
数据结构 1
2401_83575662的博客
09-14 296
算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为 输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《程序员代码面试指南》。4.算法的效率衡量一个算法的好坏，要从它的程序的时间复杂度和空间复杂度两方面来分析。时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。5.时间复杂度。
【数据结构】之排序
weixin_62848751的博客
09-14 567
时间复杂度：O（n^2） 当数据本身有序时，时间复杂度：O（n）空间复杂度：O（1）稳定性：稳定应用场景：数据基本趋于有序，建议使用直接插入排序。
【JavaScript】数据结构之字典 & 哈希表
票票的博客
09-14 359
数据结构之字典和哈希表
SDUT基础语法2--控制语句
09-10
SDUT基础语法2--控制语句可以通过使用if语句和循环语句来实现程序的控制流程。在给出的引用中，给出了一个例子，用于计算倒数之和。该程序使用了for循环来计算从1到n的倒数，并累加求和。在每次循环中，将当前的倒数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值