前插法初始化链表

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<string.h>
  4. int len = 0;
  5. typedef struct Node {
  6. int data;
  7. struct Node *next;
  8. }LinkList;
  9. LinkList *IntiList(int n)//若倒置需要前插法初始化
  10. {
  11. LinkList *phead;//开辟一个头指针(无需开辟头结点)
  12. phead = NULL;//注意初始化头指针
  13. for (int i = 0; i < n; i++){
  14. LinkList *p = (LinkList*)malloc(sizeof(LinkList));//开辟一个新结点
  15. scanf("%d", &p->data);
  16. p->next = NULL;
  17. if (phead == NULL){//如果链表为空,则把新开的第一个结点做头结点
  18. phead = p;}
  19. else{//前插法
  20. p->next = phead;
  21. phead = p;}
  22. len++;}
  23. return phead;
  24. }

插入操作的注意事项
1.若链表为空,则当插入位置为1时,插入成功。
2.若插入位置大于长度,则插入失败
3.插入需找到要插入的位置之前的位置

  1. LinkList *insert(LinkList *phead)//一定要返回phead
  2. {
  3. LinkList *p = phead;
  4. int n, m;
  5. scanf("%d %d", &n, &m);
  6. if(n>len)
  7. {
  8. if (len == 0)//特殊判断长度为0的情况
  9. {
  10. if (n == 1)
  11. {
  12. LinkList *pNode = (LinkList *)malloc(sizeof(LinkList));
  13. pNode->data = m;
  14. phead = pNode;
  15. pNode->next = NULL;
  16. len++;
  17. printf("insert OK\n");
  18. return phead;
  19. }
  20. else {
  21. printf("insert fail\n");
  22. return phead;
  23. }
  24. }
  25. }
  26. else
  27. {
  28. if (n == 1)//如果链表不为空,又想在头部插入
  29. {
  30. LinkList *pNode = (LinkList *)malloc(sizeof(LinkList));
  31. pNode->next = phead;
  32. pNode->data = m;
  33. phead = pNode;
  34. }
  35. else if(n==len)//想在尾部之前插入一个数
  36. {
  37. for (int i = 1; i < len-1; i++)
  38. p = p->next;
  39. LinkList *pNode = (LinkList *)malloc(sizeof(LinkList));
  40. pNode->data = m;
  41. pNode->next = p->next;
  42. p->next = pNode;}
  43. else {
  44. for (int i = 1; i < n-1; i++)//在中间任意位置插入,先找到插入位置之前
  45. p->next = p;
  46. LinkList *pNode = (LinkList *)malloc(sizeof(LinkList));
  47. pNode->data = m;
  48. pNode->next = p->next;
  49. p->next = pNode;}
  50. len++;
  51. printf("insert OK\n");
  52. return phead;
  53. }
  54. }

//获取元素

  1. int get(LinkList *phead)
  2. {
  3. int n = 0;
  4. scanf("%d", &n);
  5. LinkList*p = phead;
  6. if (n > len)
  7. {
  8. printf("get fail");
  9. return 0;
  10. }
  11. else {
  12. for (int i = 1; i < n; i++)
  13. {
  14. p = p->next;
  15. }
  16. printf("%d\n", p->data);
  17. }
  18. }

删除操作:与插入操作一样,找到需删除节点位置的前一个
头结点与尾结点需要特殊处理

  1. LinkList* Delete(LinkList *phead)
  2. {
  3. LinkList *p = phead;
  4. int n = 0;
  5. scanf("%d", &n);
  6. if (n > len)
  7. {
  8. printf("delete fail\n");
  9. return 0;
  10. }
  11. else {
  12. if (n == 1)//n==1时特殊判断
  13. {
  14. phead = p->next;
  15. free(p);
  16. }
  17. else if (n == len)//想删除最后一个节点
  18. {
  19. for (int i = 1; i < len-1; i++)//循环一定是从1到n-1。
  20. {
  21. p = p->next;
  22. }
  23. p->next = NULL;
  24. }
  25. else
  26. {
  27. for (int i = 1; i < n-1; i++)//欲删除n,则从i=1开始移动n-1次到n之前
  28. //先找到待删除的前一个位置
  29. p = p->next;//现在p在待删除节点之前
  30. LinkList *q = p->next;
  31. p->next = p->next->next;
  32. free(q);}
  33. }
  34. len--;
  35. printf("delete OK\n");
  36. return phead;
  37. }

显示链表

  1. void show(LinkList *phead)
  2. {
  3. if (len == 0)
  4. {
  5. printf("Link list is empty\n");
  6. }
  7. else
  8. {
  9. LinkList *p = phead;
  10. while (p!= NULL)
  11. {
  12. printf("%d ", p->data);
  13. p = p->next;
  14. }
  15. printf("\n");
  16. }
  17. }

以下是完整代码

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<string.h>
  4. int len = 0;
  5. typedef struct Node {
  6. int data;
  7. struct Node *next;
  8. }LinkList;
  9. LinkList *IntiList(int n)//前插法初始化
  10. {
  11. LinkList *phead;//开辟节点和开辟指针是两个意思!!!!
  12. phead = NULL;
  13. for (int i = 0; i < n; i++)
  14. {
  15. LinkList *p = (LinkList*)malloc(sizeof(LinkList));
  16. scanf("%d", &p->data);
  17. p->next = NULL;
  18. if (phead == NULL)
  19. {
  20. phead = p;
  21. }
  22. else
  23. {
  24. p->next = phead;
  25. phead = p;
  26. }
  27. len++;
  28. }
  29. return phead;
  30. }
  31. LinkList *insert(LinkList *phead)//一定要返回phead
  32. {
  33. LinkList *p = phead;
  34. int n, m;
  35. scanf("%d %d", &n, &m);
  36. if(n>len)
  37. {
  38. if (len == 0)
  39. {
  40. if (n == 1)
  41. {
  42. LinkList *pNode = (LinkList *)malloc(sizeof(LinkList));
  43. pNode->data = m;
  44. phead = pNode;
  45. pNode->next = NULL;
  46. //插入
  47. len++;
  48. printf("insert OK\n");
  49. return phead;
  50. }
  51. else {
  52. printf("insert fail\n");
  53. return phead;
  54. }
  55. }
  56. }
  57. else
  58. {
  59. if (n == 1)
  60. {
  61. LinkList *pNode = (LinkList *)malloc(sizeof(LinkList));
  62. pNode->next = phead;
  63. pNode->data = m;
  64. phead = pNode;
  65. }
  66. else if(n==len)//想在尾部之前插入一个数
  67. {
  68. for (int i = 1; i < len-1; i++)
  69. {
  70. p = p->next;
  71. }
  72. LinkList *pNode = (LinkList *)malloc(sizeof(LinkList));
  73. pNode->data = m;
  74. pNode->next = p->next;
  75. p->next = pNode;
  76. //找到尾部之前
  77. }
  78. else {//在中间插入
  79. for (int i = 1; i < n-1; i++)//在n插入
  80. {
  81. p->next = p;
  82. }
  83. LinkList *pNode = (LinkList *)malloc(sizeof(LinkList));
  84. pNode->data = m;
  85. pNode->next = p->next;
  86. p->next = pNode;
  87. }
  88. len++;
  89. printf("insert OK\n");
  90. return phead;
  91. }
  92. //插入尾巴
  93. //插入头部
  94. //插入中间
  95. }
  96. int get(LinkList *phead)
  97. {
  98. int n = 0;
  99. scanf("%d", &n);
  100. LinkList*p = phead;
  101. if (n > len)
  102. {
  103. printf("get fail");
  104. return 0;
  105. }
  106. else {
  107. for (int i = 1; i < n; i++)
  108. {
  109. p = p->next;
  110. }
  111. printf("%d\n", p->data);
  112. }
  113. }
  114. LinkList* Delete(LinkList *phead)//这里传入的是指针形参,该指针移动不会影响原来的头指针,但如果释放该指针指向的空间,则原来指针的指向也为空
  115. {
  116. LinkList *p = phead;
  117. int n = 0;
  118. scanf("%d", &n);
  119. if (n > len)
  120. {
  121. printf("delete fail\n");
  122. return 0;
  123. }
  124. else {
  125. if (n == 1)
  126. {
  127. phead = p->next;
  128. free(p);
  129. }
  130. else if (n == len)//想删除最后一个节点
  131. {
  132. for (int i = 1; i < len-1; i++)//i=1,一定是n-1!
  133. {
  134. p = p->next;
  135. }
  136. p->next = NULL;
  137. }
  138. else
  139. {
  140. for (int i = 1; i < n-1; i++)//欲删除n,则从1开始移动n-1次到n之前
  141. //先找到待删除的前一个位置
  142. p = p->next;//现在p在待删除节点之前
  143. LinkList *q = p->next;
  144. p->next = p->next->next;
  145. free(q);
  146. }
  147. //头删,尾删,中间删除
  148. }
  149. len--;
  150. printf("delete OK\n");
  151. return phead;
  152. }
  153. void show(LinkList *phead)
  154. {
  155. if (len == 0)
  156. {
  157. printf("Link list is empty\n");
  158. }
  159. else
  160. {
  161. LinkList *p = phead;
  162. while (p!= NULL)
  163. {
  164. printf("%d ", p->data);
  165. p = p->next;
  166. }
  167. printf("\n");
  168. }
  169. }
  170. int main()
  171. {
  172. int n = 0,m=0;
  173. scanf("%d", &n);
  174. LinkList *phead = IntiList(n);
  175. scanf("%d", &m);
  176. while (m--)
  177. {
  178. char str[200];
  179. scanf("%s", str);
  180. if (strcmp(str, "show") == 0)
  181. {
  182. show(phead);
  183. }
  184. else if (strcmp(str, "get") == 0)
  185. {
  186. get(phead);
  187. }
  188. else if (strcmp(str, "delete") == 0)
  189. {
  190. phead=Delete(phead);
  191. }
  192. else if (strcmp(str, "insert") == 0)
  193. {
  194. phead = insert(phead);
  195. }
  196. }
  197. }
点赞(0)
 

9.9 分

2 人评分

 

C语言网提供由在职研发工程师或ACM蓝桥杯竞赛优秀选手录制的视频教程,并配有习题和答疑,点击了解:

一点编程也不会写的:零基础C语言学练课程

解决困扰你多年的C语言疑难杂症特性的C语言进阶课程

从零到写出一个爬虫的Python编程课程

只会语法写不出代码?手把手带你写100个编程真题的编程百练课程

信息学奥赛或C++选手的 必学C++课程

蓝桥杯ACM、信息学奥赛的必学课程:算法竞赛课入门课程

手把手讲解近五年真题的蓝桥杯辅导课程

评论列表 共有 1 条评论

沉在海里的鱼 3年前 回复TA
这明明就是C语言啊,怎么标题写C++