【数据结构】 单链表的基本操作+反转+选择/直接插入/冒泡3种排序

最新推荐文章于 2020-09-16 22:30:24 发布
最新推荐文章于 2020-09-16 22:30:24 发布
阅读量1.5k 收藏 5
点赞数 1
分类专栏： 数据结构&算法 总结

整理自：链表各类操作详解。   ======每天抽时间整理=====

这个详细介绍了单链表的各种操作： 创造，插入（插入到指定的第i位or合适的插入到有序链表中），删除，打印，反转，选择排序，直接插入排序，冒泡。

链表概述
　　 链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”，每个结点都应包括两个部分：一为用户需要用的实际数据，二为下一个结点的地址。因此，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素，该元素不再指向其它元素，它称为“表尾”，它的地址部分放一个“NULL”（表示“空地址”），链表到此结束。
        链表的各类操作包括：学习单向链表的创建、删除、  插入（无序、有序）、输出、  排序（选择、插入、冒泡）、反序等等。

       单向链表的图示：
       ---->[NULL]
      head

      图1：空链表

       ---->[p1]---->[p2]...---->[pn]---->[NULL]
      head   p1->next  p2->next   pn->next

      图2：有N个节点的链表

      创建n个节点的链表的函数为：

[cpp]  view plain  copy
  1. #include "stdlib.h"  
  2. #include "stdio.h"  
  3.   
  4. #define NULL 0  
  5. #define LEN sizeof(struct student)  
  6.   
  7. struct student  
  8. {  
  9.     int num;              //学号   
  10.     float score;          //分数，其他信息可以继续在下面增加字段  
  11.     struct student *next;       //指向下一节点的指针  
  12. };  
  13.   
  14. int n;  //节点总数   
  15. /* 
  16. ========================== 
  17. 功能：创建n个节点的链表 
  18. 返回：指向链表表头的指针 
  19. ========================== 
  20. */  
  21. struct student *Create()  
  22. {  
  23.     struct student *head;       //头节点  
  24.     struct student *p1 = NULL;  //p1保存创建的新节点的地址  
  25.     struct student *p2 = NULL;  //p2保存原链表最后一个节点的地址  
  26.   
  27.     n = 0;          //创建前链表的节点总数为0：空链表  
  28.     p1 = (struct student *) malloc (LEN);   //开辟一个新节点  
  29.     p2 = p1;            //如果节点开辟成功，则p2先把它的指针保存下来以备后用  
  30.   
  31.     if(p1==NULL)        //节点开辟不成功  
  32.     {  
  33.         printf ("\nCann't create it, try it again in a moment!\n");  
  34.         return NULL;  
  35.     }  
  36.     else                //节点开辟成功  
  37.     {  
  38.         head = NULL;        //开始head指向NULL  
  39.         printf ("Please input %d node -- num,score: ", n + 1);  
  40.         scanf ("%d %f", &(p1->num), &(p1->score));    //录入数据  
  41.     }  
  42.     while(p1->num != 0)      //只要学号不为0，就继续录入下一个节点  
  43.     {  
  44.         n += 1;         //节点总数增加1个  
  45.         if(n == 1)      //如果节点总数是1，则head指向刚创建的节点p1  
  46.         {  
  47.             head = p1;  
  48.             p2->next = NULL;  //此时的p2就是p1,也就是p1->next指向NULL。  
  49.         }  
  50.         else  
  51.         {  
  52.             p2->next = p1;   //指向上次下面刚刚开辟的新节点  
  53.         }  
  54.   
  55.         p2 = p1;            //把p1的地址给p2保留，然后p1产生新的节点  
  56.   
  57.         p1 = (struct student *) malloc (LEN);  
  58.         printf ("Please input %d node -- num,score: ", n + 1);  
  59.         scanf ("%d %f", &(p1->num), &(p1->score));  
  60.     }  
  61.     p2->next = NULL;     //此句就是根据单向链表的最后一个节点要指向NULL  
  62.   
  63.     free(p1);           //p1->num为0的时候跳出了while循环，并且释放p1  
  64.     p1 = NULL;          //特别不要忘记把释放的变量清空置为NULL,否则就变成"野指针"，即地址不确定的指针  
  65.     return head;        //返回创建链表的头指针   
  66. }  

      输出链表中节点的函数为：

[cpp]  view plain  copy
  1. /* 
  2. =========================== 
  3.  功能：输出节点 
  4.  返回： void 
  5. =========================== 
  6. */  
  7. void Print(struct student *head)  
  8. {  
  9.     struct student *p;  
  10.     printf ("\nNow , These %d records are:\n", n);  
  11.     p = head;  
  12.     if(head != NULL)        //只要不是空链表，就输出链表中所有节点  
  13.     {  
  14.         printf("head is %o\n", head);    //输出头指针指向的地址  
  15.         do  
  16.         {  
  17.             /* 
  18.             输出相应的值：当前节点地址、各字段值、当前节点的下一节点地址。 
  19.             这样输出便于读者形象看到一个单向链表在计算机中的存储结构，和我们 
  20.             设计的图示是一模一样的。 
  21.             */  
  22.             printf ("%o   %d   %5.1f   %o\n", p, p->num, p->score, p->next);  
  23.             p = p->next;     //移到下一个节点  
  24.         }  
  25.         while (p != NULL);  
  26.     }  
  27. }  

       单向链表的删除图示：
       ---->[NULL]
       head

       图3：空链表

      从图3可知，空链表显然不能删除

      ---->[1]---->[2]...---->[n]---->[NULL]（原链表）
      head   1->next  2->next   n->next

      ---->[2]...---->[n]---->[NULL]（删除后链表）
      head   2->next   n->next

      图4：有N个节点的链表，删除第一个节点
      结合原链表和删除后的链表，就很容易写出相应的代码。操作方法如下：
      1、你要明白head就是第1个节点，head->next就是第2个节点；
       2、删除后head指向第2个节点，就是让head=head->next,OK这样就行了。
       ---->[1]---->[2]---->[3]...---->[n]---->[NULL]（原链表）
       head   1->next  2->next  3->next   n->next

       ---->[1]---->[3]...---->[n]---->[NULL]（删除后链表）
      head   1->next  3->next   n->next

      图5：有N个节点的链表，删除中间一个（这里图示删除第2个）
      结合原链表和删除后的链表，就很容易写出相应的代码。操作方法如下：
      1、你要明白head就是第1个节点，1->next就是第2个节点，2->next就是第3个节点；
      2、删除后2，1指向第3个节点，就是让1->next=2->next。

      删除指定学号的节点的函数为：

[cpp]  view plain  copy
  1. /* 
  2. ========================== 
  3.  功能：删除指定节点 
  4.   (此例中是删除指定学号的节点) 
  5.  返回：指向链表表头的指针 
  6. ========================== 
  7. */  
  8. struct student *Del (struct student *head, int num)  
  9. {  
  10.     struct student *p1;     //p1保存当前需要检查的节点的地址  
  11.     struct student *p2;     //p2保存当前检查过的节点的地址  
  12.     if (head == NULL)       //是空链表（结合图3理解）  
  13.     {  
  14.         printf ("\nList is null!\n");  
  15.         return head;  
  16.     }  
  17.   
  18.     //定位要删除的节点  
  19.     p1 = head;  
  20.     while (p1->num != num && p1->next != NULL)    //p1指向的节点不是所要查找的，并且它不是最后一个节点，就继续往下找  
  21.     {  
  22.         p2 = p1;            //保存当前节点的地址  
  23.         p1 = p1->next;       //后移一个节点  
  24.     }  
  25.   
  26.     if(p1->num==num)     //找到了。（结合图4、5理解）  
  27.     {  
  28.         if (p1 == head)     //如果要删除的节点是第一个节点  
  29.         {  
  30.             head = p1->next; //头指针指向第一个节点的后一个节点，也就是第二个节点。这样第一个节点就不在链表中，即删除  
  31.         }  
  32.         else            //如果是其它节点，则让原来指向当前节点的指针，指向它的下一个节点，完成删除  
  33.         {  
  34.             p2->next = p1->next;  
  35.         }  
  36.   
  37.         free (p1);      //释放当前节点  
  38.         p1 = NULL;  
  39.         printf ("\ndelete %ld success!\n", num);  
  40.         n -= 1;         //节点总数减1个  
  41.     }  
  42.     else                //没有找到  
  43.     {  
  44.         printf ("\n%ld not been found!\n", num);  
  45.     }  
  46.   
  47.     return head;  
  48. }  

       单向链表的插入图示：
       ---->[NULL]（原链表）
      head

      ---->[1]---->[NULL]（插入后的链表）
      head   1->next

      图7 空链表插入一个节点
      结合原链表和插入后的链表，就很容易写出相应的代码。操作方法如下：
     1、你要明白空链表head指向NULL就是head=NULL；
     2、插入后head指向第1个节点，就是让head=1,1->next=NULL,OK这样就行了。

     ---->[1]---->[2]---->[3]...---->[n]---->[NULL]（原链表）
     head   1->next  2->next  3->next   n->next

     ---->[1]---->[2]---->[x]---->[3]...---->[n]---->[NULL]（插入后的链表）
     head   1->next  2->next  x->next  3->next   n->next

     图8：有N个节点的链表，插入一个节点（这里图示插入第2个后面）
     结合原链表和插入后的链表，就很容易写出相应的代码。操作方法如下：
    1、你要明白原1->next就是节点2，2->next就是节点3；
    2、插入后x指向第3个节点,2指向x，就是让x->next=2->next,1->next=x。

    插入指定节点的后面的函数为：

[cpp]  view plain  copy
  1. /* 
  2. ========================== 
  3.  功能：插入指定节点的后面 
  4.   (此例中是指定学号的节点) 
  5.  返回：指向链表表头的指针 
  6. ========================== 
  7. */  
  8. struct student *Insert (struct student *head, int num, struct student *node)  
  9. {  
  10.     struct student *p1;     //p1保存当前需要检查的节点的地址  
  11.     if (head == NULL)       //（结合图示7理解）  
  12.     {  
  13.         head = node;  
  14.         node->next = NULL;  
  15.         n += 1;  
  16.         return head;  
  17.     }  
  18.   
  19.     p1 = head;  
  20.     while(p1->num != num && p1->next != NULL)  //p1指向的节点不是所要查找的，并且它不是最后一个节点，继续往下找  
  21.     {  
  22.         p1 = p1->next;       //后移一个节点  
  23.     }  
  24.   
  25.     if (p1->num==num)        //找到了（结合图示8理解）  
  26.     {  
  27.         node->next = p1->next;    //显然node的下一节点是原p1的next  
  28.         p1->next = node;     //插入后，原p1的下一节点就是要插入的node  
  29.         n += 1;         //节点总数增加1个  
  30.     }  
  31.     else  
  32.     {  
  33.         printf ("\n%ld not been found!\n", num);  
  34.     }  
  35.     return head;  
  36. }  

       单向链表的反序图示：
       ---->[1]---->[2]---->[3]...---->[n]---->[NULL]（原链表）
       head   1->next  2->next  3->next   n->next

      [NULL]<----[1]<----[2]<----[3]<----...[n]<----（反序后的链表）
                1->next  2->next  3->next   n->next  head

          图9：有N个节点的链表反序
          结合原链表和插入后的链表，就很容易写出相应的代码。操作方法如下：
          1、我们需要一个读原链表的指针p2,存反序链表的p1=NULL（刚好最后一个节点的next为NULL）,还有一个临时存储变量p；
          2、p2在原链表中读出一个节点，我们就把它放到p1中，p就是用来处理节点放置顺序的问题；
          3、比如，现在我们取得一个2,为了我们继续往下取节点，我们必须保存它的next值，由原链表可知p=2->next;
          4、然后由反序后的链表可知，反序后2->next要指向1，则2->next=1;
          5、好了，现在已经反序一个节点，接着处理下一个节点就需要保存此时的信息：
          p1变成刚刚加入的2，即p1=2;p2要变成它的下一节点，就是上面我们保存的p,即p2=p。

          反序链表的函数为：

[cpp]  view plain  copy
  1. /* 
  2. ========================== 
  3.  功能：反序节点 
  4.   (链表的头变成链表的尾，链表的尾变成头) 
  5.  返回：指向链表表头的指针 
  6. ========================== 
  7. */  
  8.   
  9. struct student *Reverse (struct student *head)  
  10. {  
  11.     struct student *p;      //临时存储  
  12.     struct student *p1;     //存储返回结果  
  13.     struct student *p2;     //源结果节点一个一个取  
  14.   
  15.     p1 = NULL;          //开始颠倒时，已颠倒的部分为空  
  16.     p2 = head;          //p2指向链表的头节点  
  17.     while(p2 != NULL)  
  18.     {  
  19.         p = p2->next;  
  20.         p2->next = p1;  
  21.         p1 = p2;  
  22.         p2 = p;  
  23.     }  
  24.     head = p1;  
  25.     return head;  
  26. }  

          对链表进行选择排序的基本思想就是反复从还未排好序的那些节点中，选出键值（就是用它排序的字段，我们取学号num为键值）最小的节点，依次重新组合成一个链表。

         我认为写链表这类程序，关键是理解：head存储的是第一个节点的地址，head->next存储的是第二个节点的地址；任意一个节点p的地址，只能通过它前一个节点的next来求得。

        单向链表的选择排序图示：
         ---->[1]---->[3]---->[2]...---->[n]---->[NULL]（原链表）
         head   1->next  3->next  2->next   n->next

         ---->[NULL]（空链表）
        first
        tail

         ---->[1]---->[2]---->[3]...---->[n]---->[NULL]（排序后链表）
         first   1->next  2->next  3->next   tail->next

         图10：有N个节点的链表选择排序

        1、先在原链表中找最小的，找到一个后就把它放到另一个空的链表中；
        2、空链表中安放第一个进来的节点，产生一个有序链表,并且让它在原链表中分离出来（此时要注意原链表中出来的是第一个节点还是中间其它节点）；
        3、继续在原链表中找下一个最小的，找到后把它放入有序链表的尾指针的next,然后它变成其尾指针；

        对链表进行选择排序的函数为：

[cpp]  view plain  copy
  1. /* 
  2. ========================== 
  3.  功能：选择排序(由小到大) 
  4.  返回：指向链表表头的指针 
  5. ========================== 
  6. */  
  7. struct student *SelectSort (struct student *head)  
  8. {  
  9.     struct student *first;     //排列后有序链的表头指针  
  10.     struct student *tail;      //排列后有序链的表尾指针  
  11.     struct student *p_min;     //保留键值更小的节点的前驱节点的指针  
  12.     struct student *min;       //存储最小节点  
  13.     struct student *p;         //当前比较的节点  
  14.   
  15.     first = NULL;  
  16.     while(head != NULL)       //在链表中找键值最小的节点  
  17.     {  
  18.         //注意：这里for语句就是体现选择排序思想的地方  
  19.         for (p = head, min = head; p->next != NULL; p = p->next)  //循环遍历链表中的节点，找出此时最小的节点  
  20.         {  
  21.             if (p->next->num < min->num)     //找到一个比当前min小的节点  
  22.             {  
  23.                 p_min = p;        //保存找到节点的前驱节点：显然p->next的前驱节点是p  
  24.                 min = p->next;     //保存键值更小的节点  
  25.             }  
  26.         }  
  27.   
  28.         //上面for语句结束后，就要做两件事；一是把它放入有序链表中；二是根据相应的条件判断，安排它离开原来的链表  
  29.   
  30.         //第一件事  
  31.         if (first == NULL)     //如果有序链表目前还是一个空链表  
  32.         {  
  33.             first = min;        //第一次找到键值最小的节点  
  34.             tail = min;        //注意：尾指针让它指向最后的一个节点  
  35.         }  
  36.         else              //有序链表中已经有节点  
  37.         {  
  38.             tail->next = min;    //把刚找到的最小节点放到最后，即让尾指针的next指向它  
  39.             tail = min;           //尾指针也要指向它  
  40.         }  
  41.   
  42.         //第二件事  
  43.         if (min == head)            //如果找到的最小节点就是第一个节点  
  44.         {  
  45.             head = head->next;      //显然让head指向原head->next,即第二个节点，就OK  
  46.         }  
  47.         else            //如果不是第一个节点  
  48.         {  
  49.             p_min->next = min->next;  //前次最小节点的next指向当前min的next,这样就让min离开了原链表  
  50.         }  
  51.     }  
  52.   
  53.     if (first != NULL)      //循环结束得到有序链表first  
  54.     {  
  55.         tail->next = NULL;   //单向链表的最后一个节点的next应该指向NULL  
  56.     }  
  57.     head = first;  
  58.     return head;  
  59. }  

           对链表进行直接插入排序的基本思想就是假设链表的前面n-1个节点是已经按键值（就是用它排序的字段，我们取学号num为键值）排好序的，对于节点n在这个序列中找插入位置，使得n插入后新序列仍然有序。按照这种思想，依次对链表从头到尾执行一遍，就可以使无序链表变为有序链表。

         单向链表的直接插入排序图示：
         ---->[1]---->[3]---->[2]...---->[n]---->[NULL]（原链表）
        head   1->next  3->next  2->next   n->next

         ---->[1]---->[NULL]（从原链表中取第1个节点作为只有一个节点的有序链表）
        head
        图11

        ---->[3]---->[2]...---->[n]---->[NULL]（原链表剩下用于直接插入排序的节点）
        first   3->next  2->next   n->next
        图12

        ---->[1]---->[2]---->[3]...---->[n]---->[NULL]（排序后链表）
        head   1->next  2->next  3->next   n->next

        图13：有N个节点的链表直接插入排序

       1、先在原链表中以第一个节点为一个有序链表，其余节点为待定节点。
       2、从图12链表中取节点，到图11链表中定位插入。
       3、上面图示虽说画了两条链表，其实只有一条链表。在排序中，实质只增加了一个用于指向剩下需要排序节点的头指针first罢了。
       这一点请读者务必搞清楚，要不然就可能认为它和上面的选择排序法一样了。

       对链表进行直接插入排序的函数为：

[cpp]  view plain  copy
  1. /* 
  2. ========================== 
  3.  功能：直接插入排序(由小到大) 
  4.  返回：指向链表表头的指针 
  5. ========================== 
  6. */  
  7. struct student *InsertSort (struct student *head)  
  8. {  
  9.     struct student *first;    //为原链表剩下用于直接插入排序的节点头指针  
  10.     struct student *t;        //临时指针变量：插入节点  
  11.     struct student *p,*q;     //临时指针变量  
  12.   
  13.     first = head->next;      //原链表剩下用于直接插入排序的节点链表：可根据图12来理解  
  14.     head->next = NULL;       //只含有一个节点的链表的有序链表：可根据图11来理解  
  15.   
  16.     while(first != NULL)        //遍历剩下无序的链表  
  17.     {  
  18.         //注意：这里for语句就是体现直接插入排序思想的地方  
  19.         for (t = first, q = head; ((q != NULL) && (q->num < t->num)); p = q, q = q->next);  //无序节点在有序链表中找插入的位置  
  20.   
  21.         //退出for循环，就是找到了插入的位置，应该将t节点插入到p节点之后，q节点之前  
  22.         //注意：按道理来说，这句话可以放到下面注释了的那个位置也应该对的，但是就是不能。原因：你若理解了上面的第3条，就知道了  
  23.         //下面的插入就是将t节点即是first节点插入到p节点之后，已经改变了first节点，所以first节点应该在被修改之前往后移动，不能放到下面注释的位置上去  
  24.         first = first->next; //无序链表中的节点离开，以便它插入到有序链表中  
  25.   
  26.         if (q == head)      //插在第一个节点之前  
  27.         {  
  28.             head = t;  
  29.         }  
  30.         else            //p是q的前驱  
  31.         {  
  32.             p->next = t;  
  33.         }  
  34.         t->next = q;     //完成插入动作  
  35.         //first = first->next;   
  36.     }  
  37.     return head;  
  38. }  

         对链表进行冒泡排序的基本思想就是对当前还未排好序的范围内的全部节点，自上而下对相邻的两个节点依次进行比较和调整，让键值（就是用它排 序的字段，我们取学号num为键值）较大的节点往下沉，键值较小的往上冒。即：每当两相邻的节点比较后发现它们的排序与排序要求相反时，就将它们互换。

        单向链表的冒泡排序图示：
        ---->[1]---->[3]---->[2]...---->[n]---->[NULL]（原链表）
       head   1->next  3->next  2->next   n->next

       ---->[1]---->[2]---->[3]...---->[n]---->[NULL]（排序后链表）
       head   1->next  2->next  3->next   n->next

       图14：有N个节点的链表冒泡排序

      任意两个相邻节点p、q位置互换图示:
      假设p1->next指向p，那么显然p1->next->next就指向q,
      p1->next->next->next就指向q的后继节点，我们用p2保存
      p1->next->next指针。即：p2=p1->next->next，则有：
       [  ]---->[p]---------->[q]---->[  ]（排序前）
       p1->next  p1->next->next  p2->next
       图15

       [  ]---->[q]---------->[p]---->[  ]（排序后）

       图16

      1、排序后q节点指向p节点，在调整指向之前，我们要保存原p的指向节点地址，即：p2=p1->next->next；
      2、顺着这一步一步往下推,排序后图16中p1->next->next要指的是p2->next,所以p1->next->next=p2->next;
      3、在图15中p2->next原是q发出来的指向，排序后图16中q的指向要变为指向p的，而原来p1->next是指向p的，所以p2->next=p1->next;
      4、在图15中p1->next原是指向p的，排序后图16中p1->next要指向q,原来p1->next->next（即p2)是指向q的，所以p1->next=p2;
      5、至此，我们完成了相邻两节点的顺序交换。
      6、下面的程序描述改进了一点就是记录了每次最后一次节点下沉的位置，这样我们不必每次都从头到尾的扫描，只需要扫描到记录点为止。 因为后面的都已经是排好序的了。

       对链表进行冒泡排序的函数为：

[cpp]  view plain  copy
  1. /* 
  2. ========================== 
  3.  功能：冒泡排序(由小到大) 
  4.  返回：指向链表表头的指针 
  5. ========================== 
  6. */  
  7. struct student *BubbleSort (struct student *head)  
  8. {  
  9.     struct student *endpt;    //控制循环比较  
  10.     struct student *p;        //临时指针变量  
  11.     struct student *p1,*p2;  
  12.   
  13.     p1 = (struct student *) malloc (LEN);  
  14.     p1->next = head;        //注意理解：我们增加一个节点，放在第一个节点的前面，主要是为了便于比较。因为第一个节点没有前驱，我们不能交换地址  
  15.     head = p1;                 //让head指向p1节点，排序完成后，我们再把p1节点释放掉  
  16.   
  17.     for (endpt = NULL; endpt != head; endpt = p)    //结合第6点理解  
  18.     {  
  19.         for (p = p1 = head; p1->next->next != endpt; p1 = p1->next)  
  20.         {  
  21.             if (p1->next->num > p1->next->next->num)  //如果前面的节点键值比后面节点的键值大，则交换  
  22.             {  
  23.                 p2 = p1->next->next;    //结合第1点理解  
  24.                 p1->next->next = p2->next;   //结合第2点理解  
  25.                 p2->next = p1->next;   //结合第3点理解  
  26.                 p1->next = p2;     //结合第4点理解  
  27.                 p = p1->next->next;   //结合第6点理解  
  28.             }  
  29.         }  
  30.     }  
  31.   
  32.     p1 = head;              //把p1的信息去掉  
  33.     head = head->next;       //让head指向排序后的第一个节点  
  34.     free (p1);          //释放p1  
  35.     p1 = NULL;          //p1置为NULL，保证不产生“野指针”，即地址不确定的指针变量  
  36.   
  37.     return head;  
  38. }  

        有序链表插入节点示意图：

        ---->[NULL]（空有序链表）
        head

       图18：空有序链表（空有序链表好解决，直接让head指向它就是了。）

       以下讨论不为空的有序链表。
        ---->[1]---->[2]---->[3]...---->[n]---->[NULL]（有序链表）
        head   1->next  2->next  3->next   n->next

       图18：有N个节点的有序链表

       插入node节点的位置有两种情况：一是第一个节点前，二是其它节点前或后。

       ---->[node]---->[1]---->[2]---->[3]...---->[n]---->[NULL]
       head  node->next  1->next  2->next  3->next   n->next

       图19：node节点插在第一个节点前

       ---->[1]---->[2]---->[3]...---->[node]...---->[n]---->[NULL]
      head   1->next  2->next  3->next    node->next  n->next

       插入有序链表的函数为：

[cpp]  view plain  copy
  1. /* 
  2. ========================== 
  3.  功能：插入有序链表的某个节点的后面(从小到大) 
  4.  返回：指向链表表头的指针 
  5. ========================== 
  6. */  
  7.   
  8. struct student *SortInsert (struct student *head, struct student *node)  
  9. {  
  10.     struct student *p;      //p保存当前需要检查的节点的地址  
  11.     struct student *t;      //临时指针变量  
  12.   
  13.     if (head == NULL)       //处理空的有序链表  
  14.     {  
  15.         head = node;  
  16.         node->next = NULL;  
  17.         n += 1;         //插入完毕，节点总数加  
  18.         return head;  
  19.     }  
  20.   
  21.     p = head;             //有序链表不为空  
  22.     while(p->num < node->num && p != NULL)    //p指向的节点的学号比插入节点的学号小，并且它不等于NULL  
  23.     {  
  24.         t = p;            //保存当前节点的前驱，以便后面判断后处理  
  25.         p = p->next;     //后移一个节点  
  26.     }  
  27.   
  28.     if (p == head)      //刚好插入第一个节点之前  
  29.     {  
  30.         node->next = p;  
  31.         head = node;  
  32.     }  
  33.     else                 //插入其它节点之后  
  34.     {  
  35.         t->next = node;      //把node节点加进去  
  36.         node->next = p;  
  37.     }  
  38.     n += 1;         //插入完毕，节点总数加1  
  39.   
  40.     return head;  
  41. }  

综上所述，链表的各类操作函数的完整代码如下：






六、反序：


      ------->[1]------->[2]------->[3]------->[n]---->[NULL]（原链表）
head   1->next  2->next  3->next   n->next                              

                                           p2                                                               p1

                ------->[n]------->[3]------->[2]------->[1]---->[NULL]（反序后的链表）
head  n->next  3->next  2->next   1->next                            


图 ：N个节点的链表反序

对比上图中的链表，操作方法如下：
          1、我们需要一个读原链表的指针p2，存反序链表的p1=NULL（刚好最后一个节点[n]的next为NULL），还有一个临时存储变量p；
          2、p2在原链表中读出一个节点，我们就把它放到p1中，p只是处理节点放置顺序用的；
代码（无头结点的）：

/*========================== 
 功能：反序节点 (链表的头变成链表的尾，链表的尾变成头) 
 返回：指向链表表头的指针 
========================== 
*/  
  
struct student *Reverse (struct student *head)  
{  
    Node *p, *p1, *p2;   //P:临时存储  P1:存储返回结果，逐渐构造新链表   P2:逐个取原链表的节点
    p1 = NULL;          //见图 
    p2 = head;          //见图  
    while(p2 != NULL)  
    {  
        p = p2->next;  
        p2->next = p1;  
        p1 = p2;  
        p2 = p;  
    }  
    head = p1;  
    return head;  
}
第一轮把head指的节点挪到最后了，∴ 是没头结点哒




Dr_Unknown
关注
专栏目录
链表的基本操作
weixin_45775631的博客
05-02 440
一、链表简介 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 二、力扣题目 19. 删除链表的倒数第 N 个结点 解析：19.删除链表的倒数第N个节点 参考链接 https://blog.csdn.net/weixin_56504344/article/details/115560019 ...
数据结构--单向链表及其增、删、改、查、排序等操作的实现（C语言）
羟基与苯的博客
04-10 2573
文章目录🎃链表🎃单向链表的实现（C语言）📌结点类型描述📌1.创建初始化一个链表结点📌2.从链表尾部插入数据📌3.链表遍历打印📌4.查找链表：按结点序号查找📌5.查找链表：按数据内容查找📌6.在任意位置插入一个数据📌7.删除链表：按结点序号删除📌8.删除链表：按数据内容删除📌9.free释放内存📌10.求链表数据个数🎃单向链表总结 本章内容：单链表的概念；单链表结点模型；单链表的各运算实现。 本文涉及实现单链表完整代码已提交至码云Gitee中，供读者参考。 🎃链表 我们之前实现了数据结构中第一个结构–顺序
链表各类操作详解
ajwh64482的博客
07-07 1011
链表概述　　 链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”，每个结点都应包括两个部分：一为用户需要用的实际数据，二为下一个结点的地址。因此，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素...
链表操作
lianghui0811
09-25 462
链表 链表是一个基本数据结构。它由一系列节点组成，每个包含任意数据字段和一个或指向下一个或以前的节点的引用（指针）。        注意：最后一个节点必须值空 比传统阵列的一个链表的主要好处是，挂钩项目的顺序可能会有所不同，在内存中或存储在磁盘上的数据项的顺序，允许项目清单进行不同的顺序遍历。 链表是一个自我指示的数据类型，因为它包含一个指针或链接到另一个相同类型的数据。链表允许在固定时间
C语言实现单链表的基本操作
潜龙
04-21 800
内容包括链表的创建，增加、删除节点，链表的逆序、排序和销毁等。 [cpp] view plaincopy #include   #include      typedef struct node   {       int data;       node* pNext;   }Node;      //链表的操作，以有头节点为
单链表基本操作.rar
最新发布
04-01
单链表是一种基础的数据结构，它在计算机科学中扮演着重要的角色，特别是在数据存储和算法实现方面。这个压缩包文件“单链表基本操作.rar”包含了一个名为“单链表基本操作.docx”的文档，我们可以从中学习到关于...
面试-Java一些常见面试题+题解之数据结构-DataStructure.zip
03-03
- 常见的排序算法：冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序。 - 排序算法的时间复杂度和稳定性分析。 - 在Java中实现各种排序算法的代码示例。 9. **堆**： - 堆的基本概念，最大堆和最小堆...
数据结构之单链表
qq_41278826的博客
10-27 929
0、目录 定义 存储表示 基本操作实现 初始化 取值 查找 插入 删除 创建 前插法创建 后插法创建 求表长 遍历 完整代码 1、定义   线性表链式存储结构的特点是：用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。因此，为了表示每个数据元素 ai 与其直接后继数据元素 ai+1 之间的逻辑关系，对数据元素 ai 来说，除了存储其本身的信息之...
数据结构题库：单链表（一）
weixin_47560260的博客
09-16 1969
1.栈和队列的共同特点是（只允许在端点处插入和删除元素） 4.栈通常采用的两种存储结构是（线性存储结构和链表存储结构） 5.下列关于栈的叙述正确的是（D） A.栈是非线性结构B.栈是一种树状结构C.栈具有先进先出的特征D.栈有后进先出的特征 6.链表不具有的特点是（B）A.不必事先估计存储空间 B.可随机访问任一元素 C.插入删除不需要移动元素 D.所需空间与线性表长度成正比 7.用链表表示线性表的优点是（便于插入和删除操作） 8.在单链表中，增加头结点的目的是（方便运算的实...
链表的操作
黑脉金的博客
10-16 464
#include #include #include #define maxsize 100 typedef int datatype; using namespace std; datatype x,i; typedef struct seqnode { datatype data; int size; struct seqnode *next; } seqnode,
链表操作（全）
weixin_41440480的博客
11-06 207
#include<stdio.h> #include<stdlib.h> #include<stdbool.h> typedef struct Node{ int data; struct Node * pNext; }NODE,*PNODE;//相当于struct Node NODE,struct Node *PNODE; //函数声明 PNODE cr...
数据结构与算法基础操作详解：链表、栈、队列与排序
本合集涵盖了线性表、栈、队列、串以及二叉树等核心数据结构，以及对应的基本操作方法。以下是各部分的详细知识点： 1. **线性表及其操作**： - **尾插法建立单链表并顺序输出**：通过动态内存分配创建链表节点，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值