双向循环列表使用范例

最新推荐文章于 2023-06-22 23:37:00 发布
最新推荐文章于 2023-06-22 23:37:00 发布
阅读量558 收藏
点赞数
分类专栏： 视频
  1. 转载注明出处:http://blog.sina.com.cn/s/blog_8795b0970101jj27.html
  2. #include
  3. #include
  4. #include
  5. //#include
  6. #define N 100
  7. //#define CHIN
  8. typedef struct student
  9. {
  10. int studentID;
  11. char name[N];
  12. int age;
  13. int sex;
  14. }STUDENT;
  15. typedef struct score
  16. {
  17. int chinese;
  18. int math;
  19. int english;
  20. int average;
  21. int total;
  22. }SCORE;
  23. typedef struct node
  24. {
  25. STUDENT stu;
  26. SCORE sc;
  27. struct node *next;
  28. struct node *pione;
  29. }NODE;
  30. extern NODE * mycreate();
  31. extern NODE * myinsert(NODE *,STUDENT *,SCORE *);
  32. extern void mycopy(NODE *,STUDENT *,SCORE *);
  33. extern void myprint(NODE *);
  34. extern NODE * myremove(NODE **,int);
  35. extern int Doublelinklistlen(NODE *);
  36. //extern NODE * mysearch(NODE *);
  37. //extern NODE * mysort(NODE *);
  38. extern void display(NODE *);
  39. extern void addstudent(NODE *);
  40. extern void lookover(NODE *);
  41. extern void deletestudent(NODE *);
  42. extern NODE * mysearch(NODE *,int);
  43. extern void searchinfo(NODE *);
  44. //extern NODE *mysort(NODE *);
  45. //extern void sortinfo(NODE *);
  46. extern void printnode(NODE *);


StudentManage.c:

[csharp]  view plain copy print ?
  1. #include "StudentManage.h"
  2. void mycopy(NODE *node,STUDENT *student,SCORE *score)
  3. {
  4. node->stu.studentID = student->studentID;
  5. strcpy(node->stu.name,student->name);
  6. node->stu.age = student->age;
  7. node->stu.sex = student->sex;
  8. node->sc.chinese = score->chinese;
  9. node->sc.math = score->math;
  10. node->sc.english = score->english;
  11. node->sc.average = score->average;
  12. node->sc.total = score->total;
  13. }
  14. NODE * mycreate()
  15. {
  16. NODE *head = (NODE *)malloc(sizeof(NODE));
  17. head->stu.studentID = 0;
  18. head->next = head;
  19. head->pione = head;
  20. return head;
  21. }
  22. NODE * myinsert(NODE *head,STUDENT *student,SCORE *score)
  23. {
  24. if(head->stu.studentID == 0)
  25. {
  26. mycopy(head,student,score);
  27. }
  28. else
  29. {
  30. NODE *last = head;
  31. while(last->next != head)
  32. {
  33. last = last->next;
  34. }
  35. NODE *p = (NODE *)malloc(sizeof(NODE));
  36. memset(p,0,sizeof(p));
  37. mycopy(p,student,score);
  38. head->pione = p;
  39. last->next = p;
  40. p->next = head;
  41. p->pione = last;
  42. }
  43. return head;
  44. }
  45. void myprint(NODE *head)
  46. {
  47. NODE *q = (NODE *)malloc(sizeof(NODE));
  48. q = head;
  49. int i = 1;
  50. while(q->next != head)
  51. //while(i < Doublelinklistlen(head))
  52. {
  53. printf("No.%d:ID:%d\tName:%s\tAge:%d\tSex:%d\n",i,q->stu.studentID,q->stu.name,q->stu.age,q->stu.sex);
  54. printf(" Chinese:%d\tMath:%d\tEnglish:%d\tAverage:%d\tTotal:%d\n",q->sc.chinese,q->sc.math,q->sc.english,q->sc.average,q->sc.total);
  55. i++;
  56. q = q->next;
  57. printf("\n");
  58. }
  59. printf("No.%d:ID:%d\tName:%s\tAge:%d\tSex:%d\n",i,q->stu.studentID,q->stu.name,q->stu.age,q->stu.sex);
  60. printf(" Chinese:%d\tMath:%d\tEnglish:%d\tAverage:%d\tTotal:%d\n",q->sc.chinese,q->sc.math,q->sc.english,q->sc.average,q->sc.total);
  61. }
  62. void printnode(NODE *node)
  63. {
  64. if(node != NULL)
  65. {
  66. printf("ID:%d\tName:%s\tAge:%d\tSex:%d\n",node->stu.studentID,node->stu.name,node->stu.age,node->stu.sex);
  67. printf("Chinese:%d\tMath:%d\tEnglish:%d\tAverage:%d\tTotal:%d\n",node->sc.chinese,node->sc.math,node->sc.english,node->sc.average,node->sc.total);
  68. }
  69. else
  70. {
  71. printf(" ");
  72. }
  73. printf("\n");
  74. }
  75. int Doublelinklistlen(NODE *head)
  76. {
  77. int len = 0;
  78. NODE *q = head;
  79. while(q->next != head)
  80. {
  81. len++;
  82. q = q->next;
  83. }
  84. return (len + 1);
  85. }
  86. NODE * myremove(NODE **head,int studentID)
  87. {
  88. //#define __DDD__
  89. NODE *q = (NODE *)malloc(sizeof(NODE));
  90. q = *head;
  91. int j = 0;
  92. while(q->stu.studentID != studentID)
  93. {
  94. j++;
  95. q = q->next;
  96. if(j >= Doublelinklistlen(*head))
  97. {
  98. #ifdef __DDD__
  99. printf("No Such Student has The studentID!\n");
  100. printf("Delete Student Failure!\n");
  101. #endif
  102. return *head;
  103. }
  104. }
  105. NODE *pre = q->pione;
  106. NODE *ne = q->next;
  107. //pre->next = ne;
  108. //ne->pione = pre;
  109. if(q == *head)
  110. {
  111. (*head) = (*head)->next;
  112. pre->next = (*head);
  113. (*head)->pione = pre;
  114. free(q);
  115. q = NULL;
  116. }
  117. else
  118. {
  119. pre->next = ne;
  120. ne->pione = pre;
  121. free(q);
  122. q = NULL;
  123. }
  124. #ifdef __DDD__
  125. printf("Delete Student Success!\n");
  126. #endif
  127. return (*head);
  128. }
  129. NODE * mysearch(NODE *head,int info)
  130. {
  131. NODE *q = head;
  132. int j = 0;
  133. #if 0
  134. int count = 0;
  135. for(i = 0; i < Doublelinklistlen(head); i++)
  136. {
  137. if((num == 1) && (q->stu.studentID == (int)info))
  138. {
  139. printnode(q);
  140. count++;
  141. continue;
  142. }
  143. else if((num == 2) && (strcpy(q->stu.name,(char *)info) == 0))
  144. {
  145. printnode(q);
  146. count++;
  147. continue;
  148. }
  149. else if((num == 3) && (q->stu.age == (int)info))
  150. {
  151. printnode(q);
  152. count++;
  153. continue;
  154. }
  155. else if((num == 4) && (q->stu.sex == (int)info))
  156. {
  157. printnode(q);
  158. count++;
  159. continue;
  160. }
  161. else
  162. {
  163. ;
  164. }
  165. q = q->next;
  166. }
  167. if(count == 0)
  168. {
  169. printf("No infomation about you input!\n");
  170. }
  171. #endif
  172. #if 1
  173. while(q->stu.studentID != info)
  174. {
  175. j++;
  176. q = q->next;
  177. if(j > Doublelinklistlen(head))
  178. {
  179. printf("No This Student!\n");
  180. return NULL;
  181. }
  182. }
  183. //printnode(q);
  184. return q;
  185. #endif
  186. }
  187. #if 0
  188. NODE * mysort(NODE *head)
  189. {
  190. NODE *newhead = mycreate();
  191. NODE *newlast = newhead;
  192. NODE *q = head;
  193. NODE *max = head;
  194. while(q != NULL)
  195. {
  196. printf("%d\n",__LINE__);
  197. for(; q->next != head; q = q->next)
  198. {
  199. printf("%d\n",__LINE__);
  200. //sleep(2);
  201. if(q->next->sc.total > max->sc.total)
  202. {
  203. printf("%d\n",__LINE__);
  204. max = q->next;
  205. }
  206. }
  207. printf("%d\n",__LINE__);
  208. if(max == head)
  209. {
  210. printf("%d\n",__LINE__);
  211. NODE * ne = head->next;
  212. NODE * pre = head->pione;
  213. head = head->next;
  214. ne->pione = pre;
  215. pre->next = ne;
  216. printf("%d\n",__LINE__);
  217. }
  218. else
  219. {
  220. printf("%d\n",__LINE__);
  221. NODE *ne = q->next;
  222. NODE *pre = q->pione;
  223. ne->pione = pre;
  224. pre->next = ne;
  225. printf("%d\n",__LINE__);
  226. }
  227. if(newhead->stu.studentID == 0)
  228. {
  229. printf("%d\n",__LINE__);
  230. newhead = max;
  231. newlast = max;
  232. printf("%d\n",__LINE__);
  233. }
  234. else
  235. {
  236. newlast->next = max;
  237. max->pione = newlast;
  238. max->next = newhead;
  239. newhead->pione = max;
  240. newlast = max;
  241. }
  242. q = q->next;
  243. }
  244. return newhead;
  245. }
  246. #endif

Display.c:

[csharp]  view plain copy print ?
  1. #include "StudentManage.h"
  2. void addstudent(NODE *head)
  3. {
  4. STUDENT stu;
  5. SCORE sc;
  6. printf("Please Input Student's StudentID(12XXX):");
  7. scanf("%d",&stu.studentID);
  8. printf("Please Input Student's Name:");
  9. scanf("%s",stu.name);
  10. printf("Please Input Student's Age:");
  11. scanf("%d",&stu.age);
  12. printf("Please Input Student's Sex(1:男 0:女):");
  13. scanf("%d",&stu.sex);
  14. printf("Please Input Student's Chinese Score:");
  15. scanf("%d",&sc.chinese);
  16. printf("Please Input Student's Math Score:");
  17. scanf("%d",&sc.math);
  18. printf("Please Input Student's English Score:");
  19. scanf("%d",&sc.english);
  20. sc.average = (sc.chinese + sc.math + sc.english) / 3;
  21. sc.total = sc.chinese + sc.math + sc.english;
  22. system("clear");
  23. printf("The Infomation New Student:\n");
  24. printf("ID:%d\tName:%s\tAge:%d\tSex:%d\n",stu.studentID,stu.name,stu.age,stu.sex);
  25. printf("Chinese:m\tMath:m\tEnglish:m\n",sc.chinese,sc.math,sc.english);
  26. printf("Are You Sure To Add %d:%s ？？(Y / N)",stu.studentID,stu.name);
  27. char ch;
  28. scanf("\n%c",&ch);
  29. if(ch == 'Y')
  30. {
  31. head = myinsert(head,&stu,&sc);
  32. printf("Add Student Success!\n");
  33. }
  34. printf("Press Enter To Continue...\n");
  35. getchar();
  36. getchar();
  37. }
  38. void lookover(NODE *head)
  39. {
  40. printf("The Infomation Of Student :\n");
  41. myprint(head);
  42. printf("Press Enter To Continue...");
  43. getchar();
  44. getchar();
  45. }
  46. void deletestudent(NODE *head)
  47. {
  48. int id;
  49. #define __DDD__
  50. printf("Please Input The StudentID Of Student You Want To Delete(12XXX):");
  51. scanf("%d",&id);
  52. NODE *p = mysearch(head,id);
  53. printf("The Infomation New Student:\n");
  54. printnode(p);
  55. printf("Are You Sure To Add %d:%s ？？(Y / N)",p->stu.studentID,p->stu.name);
  56. char ch;
  57. scanf("\n%c",&ch);
  58. if(ch == 'Y')
  59. {
  60. //head = myinsert(head,&stu,&sc);
  61. //printf("Add Student Success!\n");
  62. //char ch;
  63. head = myremove(&head,id);
  64. }
  65. printf("Press Enter To Continue...");
  66. getchar();
  67. getchar();
  68. }
  69. void searchinfo(NODE *head)
  70. {
  71. int n;
  72. //#define __DDD__
  73. printf("Please Input StudentID You Want To Search(12XXX):");
  74. scanf("%d",&n);
  75. NODE *p = mysearch(head,n);
  76. printnode(p);
  77. #if 0
  78. int n;
  79. int info;
  80. char name[N];
  81. printf("\n");
  82. printf("\n");
  83. printf("\n");
  84. printf("\n");
  85. printf("\n");
  86. printf("\n");
  87. printf("Please input what you want to search:");
  88. scanf("%d",&n);
  89. while((n > 4) || (n < 1))
  90. {
  91. printf("Your input must be 1-4!\n");
  92. printf("Please input again:");
  93. scanf("%d",&n);
  94. }
  95. if(n == 1)
  96. {
  97. printf("Please input StudeentID you want to search:");
  98. scanf("%d",&info);
  99. mysearch(head,1,info);
  100. }
  101. if(n == 2)
  102. {
  103. printf("Please input StudeentName you want to search:");
  104. scanf("%s",name);
  105. mysearch(head,2,name);
  106. }
  107. if(n == 3)
  108. {
  109. printf("Please input StudeentAge you want to search:");
  110. scanf("%d",&info);
  111. mysearch(head,3,info);
  112. }
  113. if(n == 4)
  114. {
  115. printf("Please input StudeentSex you want to search:");
  116. scanf("%d",&info);
  117. mysearch(head,4,info);
  118. }
  119. #endif
  120. printf("Press Enter To Continue...");
  121. getchar();
  122. getchar();
  123. }
  124. void display(NODE *head)
  125. {
  126. int choose;
  127. while(1)
  128. {
  129. system("clear");
  130. printf("\n");
  131. printf("\n");
  132. printf("\n");
  133. printf("\n");
  134. //printf("\n");
  135. printf("\n");
  136. printf("\n");
  137. printf("\n");
  138. printf("Please Input Your Choose:");
  139. scanf("%d",&choose);
  140. while((choose > 5) || (choose < 1))
  141. {
  142. printf("Your Choose Must Be 1 To 5!\n");
  143. printf("Please Input Your Choose Again:");
  144. scanf("%d",&choose);
  145. }
  146. switch(choose)
  147. {
  148. case 1:
  149. {
  150. system("clear");
  151. lookover(head);
  152. break;
  153. }
  154. case 2:
  155. {
  156. system("clear");
  157. addstudent(head);
  158. break;
  159. }
  160. case 3:
  161. {
  162. system("clear");
  163. deletestudent(head);
  164. break;
  165. }
  166. case 4:
  167. {
  168. system("clear");
  169. searchinfo(head);
  170. break;
  171. }
  172. case 5:
  173. {
  174. system("clear");
  175. exit(-1);
  176. }
  177. default:
  178. {
  179. break;
  180. }
  181. }
  182. }
  183. }


main.c:

[csharp]  view plain copy print ?
  1. #include "StudentManage.h"
  2. int main()
  3. {
  4. NODE *head = mycreate();
  5. STUDENT stu1,stu2,stu3,stu4;
  6. SCORE sc1,sc2,sc3,sc4;
  7. stu1.studentID = 12001;
  8. strcpy(stu1.name,"王明");
  9. stu1.age = 18;
  10. stu1.sex = 1;
  11. sc1.chinese = 90;
  12. sc1.math = 91;
  13. sc1.english = 92;
  14. sc1.average = 91;
  15. sc1.total = 273;
  16. stu2.studentID = 12002;
  17. strcpy(stu2.name,"张芳");
  18. stu2.age = 19;
  19. stu2.sex = 0;
  20. sc2.chinese = 80;
  21. sc2.math = 81;
  22. sc2.english = 82;
  23. sc2.average = 81;
  24. sc2.total = 243;
  25. stu3.studentID = 12003;
  26. strcpy(stu3.name,"李强");
  27. stu3.age = 19;
  28. stu3.sex = 1;
  29. sc3.chinese = 70;
  30. sc3.math = 71;
  31. sc3.english = 72;
  32. sc3.average = 71;
  33. sc3.total = 213;
  34. stu4.studentID = 12004;
  35. strcpy(stu4.name,"张小雨");
  36. stu4.age = 20;
  37. stu4.sex = 0;
  38. sc4.chinese = 60;
  39. sc4.math = 61;
  40. sc4.english = 62;
  41. sc4.average = 61;
  42. sc4.total = 183;
  43. head = myinsert(head,&stu1,&sc1);
  44. head = myinsert(head,&stu2,&sc2);
  45. head = myinsert(head,&stu3,&sc3);
  46. head = myinsert(head,&stu4,&sc4);
  47. display(head);
  48. }
pony
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言通用范例开发金典.part1.rar
08-31
范例1-46 仅设表尾指针循环链表的合并 110 ∷相关函数：MergeList_CL函数 1.3.16 正序输出双向链表 113 范例1-47 正序输出双向链表 113 ∷相关函数：ListInsert函数 ListTraverse函数 1.3.17 逆向输出双向链表 ...
线性表--双向链表
小程的博客
02-03 1304
双向链表:相比于单链表，双向链表有两个指针域，既可以保存右边的节点地址(后继)，也可以保存左边的节点地址(前驱)。如果指针域指向一个不存在的节点，则将其指针置为NULL。 。
循环列表和双向列表【转】
Uaena的博客
09-20 1590
（转自：http://xiangdonglee.iteye.com/blog/2240428） 本文围绕以下两个部分展开：一、循环链表（circular linked list）二、双向链表（double linked list）一、循环链表（circular linked list） 1. 概念 将单链表中终端结点的指针端由空指针改为指向头结点，就使整...
数据结构——带头节点的双向循环列表
最新发布
勇气是明知不可为而为之
06-22 1018
注意，在带头节点的双向循环链表中，头结点的 next 指针不再指向第一个实际节点，而是指向链表中的第一个节点。注意，在带头节点的双向循环链表中，头结点的 next 指针不再指向第一个实际节点，而是指向链表中的第一个节点。函数的参数是指向链表头结点的指针 plist 和要查找的数据 x，函数返回找到的节点的指针，如果未找到则返回 NULL。是一种特殊的双向链表，它与普通的双向链表相比，最大的区别是链表头结点的 next 指针不再指向第一个实际节点，而是指向链表中的第一个节点。
python的单向列表和双向列表（用程序来实现）
梓栋DREM
03-16 3647
1、链表（Linked list） 链表是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）。 2.单向链表 单向链表每一个节点包含两个域，一个信息域（元素域）和一个连接域。这个连接指向链表中的下一个节点，而最后一个节点的连接域则指向一个空值 如上图： 表元素域elem用来存放具体的数据 连接域next用...
双向循环链表的讲解及实现（图解+代码/C语言）
qq_62306969的博客
01-04 3516
本文主要分享了双向循环链表（带头）的写法，使用C语言完成，文中附有具体的结构图片帮助大家理解，希望对大家有帮助
C语言通用范例开发金典.part2.rar
08-31
范例1-46 仅设表尾指针循环链表的合并 110 ∷相关函数：MergeList_CL函数 1.3.16 正序输出双向链表 113 范例1-47 正序输出双向链表 113 ∷相关函数：ListInsert函数 ListTraverse函数 1.3.17 逆向输出双向链表 ...
Delphi开发范例宝典目录
03-07
实例048　程序在循环中响应界面操作　57 实例049　使用任意组件拖动窗体　58 实例050　动态创建窗体和释放窗体　59 实例051　修改提示字体及颜色　60 1.14　其他技术　61 实例052　窗口融合技术　61 实例053　给MDI...
C#程序开发范例宝典（第2版）.part08
11-12
精选570个典型范例，全面覆盖实用和热点技术，涉及面广，实用性强源于实际项目开发，帮助读者短时间掌握更多实用技术，提高编程水平范例经过精心编排，重点、难点突出，易学易懂书后附录提供快速索引，即查、即学、...
C#程序开发范例宝典（第2版）.part12
11-12
精选570个典型范例，全面覆盖实用和热点技术，涉及面广，实用性强源于实际项目开发，帮助读者短时间掌握更多实用技术，提高编程水平范例经过精心编排，重点、难点突出，易学易懂书后附录提供快速索引，即查、即学、...
数据结构 - 双向列表与循环列表
陆讯
04-28 3415
循环链表 循环链表(Circular Linked List)：是一种头尾相接的链表。其特点是最后一个结点的指针域指向链表的头结点，整个链表的指针域链接成一个环。 从循环链表的任意一个结点出发都可以找到链表中的其它结点，使得表处理更加方便灵活。 循环链表的操作 对于单循环链表，除链表的合并外，其它的操作和单线性链表基本上一致，仅仅需要在单线性链表操作算法基础上作以下简单修改：
（数据结构）带头双向循环列表的实现
Captain_ldx的博客
08-03 312
让人眼前一亮的带头双向循环链表实现方法！
双向列表（C语言版）
qq_41977600的博客
06-04 652
双向链表 大神的基操 #include <stdio.h> #include <stdlib.h> typedef struct NodeTag Node; typedef struct LinkedListTag LinkedList; struct NodeTag { Node* prev; Node* next; void* data; }; struct...
循环双列表
hibugs
07-16 493
其实就是在单链表和双链表的基础上进行了一点小小的改进。
[ 数据结构_C实现 ] 双向循环带头链表的简单实现
CSDN博客
03-22 3365
目录 1.双向循环带头链表的介绍。 2.双向循环带头链表的接口。 3.接口实现。 3.1创建新节点 3.2创建返回链表的头结点 3.3打印链表 3.4双向链表查找 3.5双向链表在pos的前面进行插入 3.5.1 头插 3.5.2 尾插 3.6双向链表删除pos位置的节点 3.6.1 尾删 3.6.2 头删 4.菜单 5.完整代码： 6.功能测试： 1.双向循环带头链表的介绍。 所谓双向循环带头链表可以分为以下3类来进行理解： 首先是双向：双向表示后一个节点可以找到
C——(单向、单向循环、双向、双向循环)链表学习总结
C_Aya的博客
07-25 1万+
这段时间一边看书一边把链表的知识总结了一下，并且画了示意图来帮助理解。主要是单向链表，单向循环链表，双向链表，双向循环链表四个部分，每个部分都包括了初始化，创建，插入，删除的基本操作，并总结了各个操作的核心代码。抽空可以看看Linux内核自带的链表(list.h)写法，增进学习。以下的链表均是不操作头节点的。一、单向链表1.单向链表：链式的存储结构，在逻辑上是连续的，每次通过一个指针来指向下一个节点
数据结构——“双向循环链表“ 易懂刨析双向循环链表（图解+代码）
热门推荐
weixin_44278698的博客
04-27 1万+
循环链表单向循环链表双向循环链表1. 双向循环链表——插入2. 双向循环链表——删除 单向循环链表 关于两个循环链表合并为一个循环链表 双向循环链表 在单链表L中，查找ai的后继Next(L，a;)，耗时仅为O(1)，因为取ai后继指针即可。 但查找a;的直接前驱Prior(L，ai);则需从链表的头指针开始，找到结点ai前一结点即是。故运算Prior(L，ai)依赖表长n，耗时为O(n)。另外，若链表中有一指针值被破坏，则整个链表脱节。这是单链表的不足 为此，引入双向链表。先定义双向链表中的结点:
双向链表的应用实例
xiaowanziddd的博客
12-17 471
双向链表的应用实例 目标：使用带头结点的双向链表实现水浒英雄排行榜管理 单向链表的缺点分析： （1）单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。 （2）单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，单链表进行删除的时候，总是需要找到待删除节点的前一个节点来进行删除。 ...
列表的循环遍历及常见操作
Pangpangbupang.
01-04 1万+
目录 列表介绍 列表的格式 打印列表 列表的遍历循环 1.使用for循环 2.使用while循环 列表的常见操作 1>添加元素("增"append, extend, insert) 2>修改元素（改） 3>查找元素("查"in, not in, index, count) 4>删除元素("删"del, pop, remove) 5>排序(sort, reverse) 列表介绍 一个字符串只能存储一个变量，我们要想一个变量中储存多个数...
使用c语言完成双向循环链表
03-21
好的，以下是使用 C 语言完成双向循环链表的代码： ``` #include #include struct Node { int data; struct Node* next; struct Node* prev; }; struct Node* head = NULL; void insert(int data) { ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值