当前位置:   article > 正文

数据结构:链表的基本用法(逆置)_数据结构将单链表所有节点逆置

数据结构将单链表所有节点逆置

1.单链表的定义

        单链表是一种链式存取的数据结构,用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的,每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置),元素就是存储数据的存储单元,指针就是连接每个结点的地址数据。

2.单链表的结构

data域:存放结点值的数据域

next域:存放结点的直接后继的地址(位置)的指针域(链域)

链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的,每个结点只有一个链域的链表称为单链表

头结点:单链表中每个结点的存储地址是存放在其前趋结点next域中,而开始结点无前趋,故应设头指针head指向开始结点。链表由头指针唯一确定,单链表可以用头指针的名字来命名。

终端结点:结点无后继,故终端结点的指针域为空,即NULL。

  1. typedef struct node{
  2. int data;
  3. struct node *next;
  4. }list;

3.链表的创建

  1. void creatlist(list *head)
  2. {
  3. int n,i;
  4. list *p,*q;
  5. printf("输入数字个数:");
  6. scanf("%d",&n);
  7. printf("输入数字:");
  8. p=head;
  9. head->next=NULL;
  10. for(i=0;i<n;i++)
  11. {
  12. q=(list*)malloc(sizeof(list));
  13. scanf("%d",&q->data);
  14. p->next=q;
  15. q->next=NULL;
  16. p=q;
  17. }
  18. getchar();
  19. }

注意:创建时候要考虑题目中有没有说要带头结点,如果要带头结点,head结点中就不能存放数据;如果不带头结点,head结点就要放数据。(上述代码是不带头结点的链表

4.链表的遍历

  1. void Print(list *head)
  2. {
  3. list *p;
  4. p=head->next;
  5. while(p!=NULL)
  6. {
  7. printf("%d ",p->data);
  8. p=p->next;
  9. }
  10. printf("\n");
  11. }

5.链表删除相同元素

  1. void Delete(list *head){
  2. list *p,*q,*t;
  3. p=head->next;
  4. int k;
  5. while(p->next!=NULL){
  6. t=p;
  7. q=t->next;
  8. k=0;
  9. if(p->data==q->data)
  10. {
  11. q=q->next; //如果相同,则q往后移
  12. t->next=q; //让t的下一个变成往后移的q,就断开了了之前q的结点
  13. if(p->next==NULL)
  14. break;
  15. k=1;
  16. }
  17. if(p->next==NULL)
  18. break;
  19. else
  20. {
  21. if(k==0)
  22. p=p->next;
  23. }
  24. }
  25. }

6.判断链表是否有序

  1. void jugde(list *head){
  2. list *p,*q;
  3. p=head->next;
  4. while(p!=NULL){
  5. q=p->next;
  6. while(q!=NULL){
  7. if(p->data<q->data){
  8. printf("格式错误!");
  9. getchar();
  10. exit(0);}
  11. else
  12. q=q->next;
  13. }
  14. p=p->next;
  15. }
  16. }

7.链表逆置

  1. void Inversion(list *head){
  2. list *p,*q;
  3. p=head->next;
  4. head->next=NULL;
  5. while(p!=NULL){
  6. q=p;
  7. p=p->next;
  8. q->next=head->next;
  9. head->next=q;
  10. }
  11. }

以下是第一步的逆置过程

 读者可以接着这个循环一直遍历下去,就能知道整个逆置过程了

8.完整代码

  1. #include<stdio.h>
  2. #include<malloc.h>
  3. #include<stdlib.h>
  4. typedef struct node{
  5. int data;
  6. struct node *next;
  7. }list;
  8. void creatlist(list *head)
  9. {
  10. int n,i;
  11. list *p,*q;
  12. printf("输入数字个数:");
  13. scanf("%d",&n);
  14. printf("输入数字:");
  15. p=head;
  16. head->next=NULL;
  17. for(i=0;i<n;i++)
  18. {
  19. q=(list*)malloc(sizeof(list));
  20. scanf("%d",&q->data);
  21. p->next=q;
  22. q->next=NULL;
  23. p=q;
  24. }
  25. getchar();
  26. }
  27. void Print(list *head)
  28. {
  29. list *p;
  30. p=head->next;
  31. while(p!=NULL)
  32. {
  33. printf("%d ",p->data);
  34. p=p->next;
  35. }
  36. printf("\n");
  37. }
  38. void Delete(list *head){
  39. list *p,*q,*t;
  40. p=head->next;
  41. int k;
  42. while(p->next!=NULL){
  43. t=p;
  44. q=t->next;
  45. k=0;
  46. if(p->data==q->data)
  47. {
  48. q=q->next;
  49. t->next=q;
  50. if(p->next==NULL)
  51. break;
  52. k=1;
  53. }
  54. if(p->next==NULL)
  55. break;
  56. else
  57. {
  58. if(k==0)
  59. p=p->next;
  60. }
  61. }
  62. }
  63. void jugde(list *head){
  64. list *p,*q;
  65. p=head->next;
  66. while(p!=NULL){
  67. q=p->next;
  68. while(q!=NULL){
  69. if(p->data<q->data){
  70. printf("格式错误!");
  71. getchar();
  72. exit(0);}
  73. else
  74. q=q->next;
  75. }
  76. p=p->next;
  77. }
  78. }
  79. void Inversion(list *head){
  80. list *p,*q;
  81. p=head->next;
  82. head->next=NULL;
  83. while(p!=NULL){
  84. q=p;
  85. p=p->next;
  86. q->next=head->next;
  87. head->next=q;
  88. }
  89. }
  90. int main(){
  91. list head;
  92. creatlist(&head);
  93. jugde(&head);
  94. Delete(&head);
  95. Inversion(&head);
  96. printf("结果:");
  97. Print(&head);
  98. getchar();
  99. return 0;
  100. }

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/Cpp五条/article/detail/680926
推荐阅读
相关标签
  

闽ICP备14008679号