链表的各类操作详解

最新推荐文章于 2024-08-13 14:59:01 发布
最新推荐文章于 2024-08-13 14:59:01 发布
阅读量1.2k 收藏 2
点赞数 1
分类专栏： C语言理解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nanjoh/article/details/53930736
版权

链表是一种常见的重要的数据结构，它是动态地进行存储分配的一种结构，它可以根据需要开辟内存单元，链表有一个头指针变量，以head

表示，它存放一个地址，该地址指向一个元素，链表中每一个元素称为结点，每个结点都应该包括两部分：一为用户需要的实际数据，

二为下一个结点的地址，因此head指向第一个元素，第一个元素又指向第二个......知道最后一个，该元素不再指向其它元素，它称之为表尾，

它的地址部分存放一个NULL，链表到此结束。

链表的各类操作包括：学习单向链表的创建，删除，插入，输入，排序等

[p1]-->[p2]-->.......[pn]-->[NULL];


#include "stdio.h"

#define NULL  0

#define LEN sizeof(struct student)

struct student{

 int num;

 float score;

 struct student *next;

};

int n;

struct student *Create()

{

struct student *head;

struct student *p1=NULL;//p1保存创建的新节点的地址

struct student *p2=NUL;//p2保存原链表最后一个节点的地址

n=0;

p1=(struct studen*)malloc(LEN);//开辟一个新节点

p2=p1;//如果节点开辟成功，则p2先把它的指针保存下来以备后用

if(p1==NULL)

{

   return NULL;

}

else

{

head=NULL;

       scanf("%d %f",&(p1->num),&(p1->score));//输入数据

}

while(p1->num!=0)

{

    n+=1;

   if(n==1)

  {

head=p1;

        p2->next=NULL;

  }

 else

{

p2->next=p1;//把p1指向上次下面刚刚开辟的新节点

}

}

p2=p1;//把p1的地址给p2保留，然后p1产生新的节点

p1=（struct student *）malloc(LEN);

scanf("%d %f",&(p1->num),&（p1->score）);

}

 p2->next=NULL;//此句就是根据单向链表的最后一个节点要指向NULL

 free(p1);//p1->NULL为0的时候跳出了while循环，并排释放p1

p1=NULL;//特别不要忘了吧释放的变量清空置为NULL，否则就变成野指针，

return head;//返回创建链表的头指针


}


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

void Printf(struct student *head)

{

  struct student *p;

  p=head;

  if(head!=NULL)

{

  printf("head is %0\n",head);

  do{

    printf("%0 %d  %5.1f",p,p->num,p->sore,p->next);

   p=p->next;

}while(p!=NULL);

}


}


单向链表的删除图：

图3：空链表

head 1->next  2->next  n->next

--[2]....->[n]--->[NULL]

head  2->next  n->next;

图4：有N个节点的链表，删除第一个节点，

结合原链表和删除后的链表，就很容易写出相应的代码，操作方法如下：

有N个节点的链表，删除第一个节点

结合原链表和删除后的链表，就很容易写出相应的代码，操作方法如下：

1.你要明白head就第一个节点，head->next就是第二个节点

2.删除后head指向第二个节点，就射让head=head->next，OK这样就行了

-->[1]-->[2]-->[3].......--->[n]--->[NULL]

head  1->next  2-->next  n->next

--->[2]....--->[n].....[NULL]

 

strtuct student *Del (Struct student *head,int num){

         struct student *p1;

         struct student *p2

   if(head==NULL){

      return head;

   }

   while(p1->num!=num&&p1->next!=null){

       p2=p1;

      p1=p1->next;

  }

   if(p1->num==num){

        if(p1==head)

        {

              head=p1->next;

         }

        else

        {

                 p2->next=p1->next;

        }

          free(p1);

          p1=NULL;

          n-=1;

  }

  else

   {

 

  }

     return head;

}

 

链表插入一个节点

结合原链表和插入后的链表，就很容易写出相应的代码，操作方法：

1.你要明白空链表head指向NULL就是head=NULL;

2.插入后head指向第1个节点，就是让head=1,1->next=NULL,ok这样就行了

 

struct student *Insert(struct student *head,int num,struct student *node)

{

          struct student *p1;

         if(head==NULL){

          head=node;

          node->next=NULL;

          n+=1;

          return head;

    }

     p1=head;

     while(p1->num!=num&&p1->next!=NULL)

    {

             p1=p1->next;

    }

     if(p1->num==num)

    {

            node->next=p1->next;

             p1->next=node;

            n+=1;

    }

    else

    {

 

   }

       return head;

}

单向链表的反省图：

--->[1]---->[2].......---->[n]----->[NULL](原链表)

[NULL]<---[1]<---[2]<----[3]<----[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.即p2=2;p2要变成他的下一节点，就是上面我们保存的p,即p2=p;

 struct student *Reverse(struct student *head)

{

      struct student *p;

      struct student *p1;

      struct student *p2;

      p1=NULL;

      p2=head;

      while(p2!=NULL){

          p=p2->next;

         p2->next=p1;

         p1=p2;

        p2=p;

     }

      head=p1;

     return head;

}

  对链表进行选择排序的基本思想就是反复从还未排好的那些节点中，选出键值最小的节点，一次重新组合成一个链表

我认为写链表这类程序，关键是理解：head存储的第一个节点的地址，head->next存储的是第二个节点的地址，任意一个节点

p的地址，只能通过它前一个节点的next来求得

  单向链表的选择排序图示：

       ---[1]---->[3]-----[2]---....--[NULL](原链表)

      head  1->next   3--next  2->next n->next-->[NULL](空链表)

    --->[1]--->[2]----[3]----[n]--->[NULL](排序后链表)

1.先在原链表中找最小的，找到一个后就把它放到另外一个空链表中；

2.空链表汇总安放第一个进来的节点，产生一个有序链表，并且让它在原链表中分离出来，

3.继续在原链表中找一个最小的，找到后把它放入有序链表的尾指针的next，然后它变成尾指针；

 

struct student *SelectSort(struct student *head)

{

       struct student *first;//排列后有序链表头指针

       struct student *tail;

       struct student *p_min;

       struct student *min;

       struct student *p;

       first =NULL;

      while(head!=NULL)

     {

             for(p=head,min=head;p->next!=NULL;p=p->next){

                   if(p->next->num<min->num)

                  {

                              p_min=p;  //保存找到的前驱节点，显然p->next

                             min=p->next;   //保存键值更小的节点

                  }

            }

               ///上面的for语句结束后，就要做两件事；一是把它放在有序链表中，二是根据相应的条件判断，安排它离开原来链表

              if(first==NULL)

              {

                     first=min;                                 //第一次找到键值最小的节点

                     tail=min;                                  //z注意：尾指针指向最后的一个节点

             }

             else

            {

                  tail->next=min; //把刚找到的最小节点放到最后，即让尾指针的next指向它

                  tail=min;          //尾指针也要指向它

            }

              if(min==head){               //如果找到的最小节点就是第一个节点

                        head=head->next; //显然让head指向原head->next，即第二个节点就OK

            }

            else

             {

                          p_min->next=min-->next;//前次最小节点的next指向当前min的next,这样就让min离开了原链表

            }

            if(first!=NULL)     //循环结束得到有序链表first

           {

                   tail->next=NULL;//单向链表的最后一个节点的next应该指向NULL

            }

             head=first;

             return head;

 

     }

}

 

对链表进行直接插入排序的基本思想就是结束链表的前面n-1节点是已经按键值，排好的，对于节点n在这个系列镇南关插入位置，使得n插入后新系列依然

按照这种思想，依次对链表从头到尾执行一笔那，就可以是变为有序链表

单向链表的直接插入排序图：

--->[1]----->[3]----[2].......----[n]----[NULL](原链表)

head  1->next   3->next  2->next  n->next

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

 1.现在原链表中易第一个节点为一个有序链表，其余节点为待定节点

  2.从图12链表中取节点，到图11链表中定位插入

  3.上面图示虽说画两条表，其实只有一条链表，在排序汇总，实质只增加了一个拥有指向剩余需要的排序节点的头指针first 罢了，

 

功能：直接插入排序（由小到大）

 struct student *InsertSort(struct student *head)

  {

         struct student *first;  //为原链表剩余下用于直接插入的节点头指针

         struct student *t;   //临时指针变量：插入节点

         struct student *p,  //临时指针变量

        first =head->next;//原链表剩余下用于直接插入排序节点链表

       head->next=NULL;

       while(first!=NULL)

       {

                 //注意：这里for语句就是体现指针插入排序思想的地方，无系节点在有序链表中找插入的位置

                //退出for循环，就是找到了插入的位置，应该讲t节点插入到p节点之后，q节点之前

               //注意：按道理来说，这句话可以放到下面注释了的那个位置也应该对的，但是就是不能，原因：

                你若理解了上面的第三条，就知道了

               //下面的插入就是将t节点即是first节点插入到q节点之后，已经改变了first节点，所以first节点应该在被修改之前往后

              移动，不能放到下面注释的位置上去

              for(t=first,q=head;((q!=NULL)&&(q->num<t->num);p=q,q=q->next))

             {

                             frist=first->next;

                            if(q==head)   //差在第一个节点之前

                            {

 

                                       head=t;

                            }

                           else                             //p是q的前驱

                          {

                                       p->next=t;

                          }

                          t->next=q;

 

             }

           return head;

 }

 

对链表进行冒泡排序的基本思想就是对的丧气还未排好的范围内的全部节点，自上而下

对相邻的两个结点一次进行比较调整，让键值较大的节点往下沉，键值较小的往上冒

 

单向链表的冒泡排序：

--->[1]----->[3]------>[2].......------[n]----->[null](原链表)

head  1-->next   3->next  2->next  n->next

---->[1]--->[2]----->[3]......---->[n]---->[NULL](排序后链表)

 

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

1.排序后q节点指向p节点，在调整指向之前，我们要保存原p的指向节点地址，即：p2=p1->next->next;

2.顺着这一步一步往下推，排序后p1->next->next 要指向的是p2->next ，所以p1->next->next=p2->next;

3.在p2->next 原来q发出来的指向，排序后q的指向要变为指向p的，而原来p1->next是指向p的，所以p2->next=p1->next;

4.在图15中p1->next 原来是指向p的，排序后图16中的p1->next 要指向q,原来p1->next->next是指向q的，所以p1->next=p2;

5.至此，我们完成了相邻两节点的顺序交换。

6.下面的程序描述改进了一点就记录了每次最后一次节点下沉的位置，这样我们不必每次都从头到尾扫描，只要扫描到记录点为止，因为后面的都已经排好系了；

功能：冒泡排序（由小到大）

   struct student *BubbleSort(struct student *head)

    {

          struct student *endpt;

          struct student *p;

          struct student *p1,*p2;

          p1=(struct student *)malloc(LEN);

           p1->next=head;

           head=p1;

          for(endpt=NULL;endpt!=head;endpt=p)

          {

                    for(p=p1=head;p1->next->next！=endpt;p1=p1->next)

                   {

                            if(p1->next->num>p1->next->next->num)

                           {

                                 p2=p1->next->next;

                                p1->next->next=p2->next;

                                p2->next=p1->next;

                               p1->next=p2;

                               p=p1->next->next;

                   

                            }

                  }

 

          }

                  p1=head;

                  head=head->next;

                 free(p1);

                p1=NULL;

                 return head;

  }

 

有N个节点的有序链表

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

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

head  node ->next   1->next   2->next   3->next  n->next;

node 节点插在第一个节点前

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

head 1->next  2->next 3->next  node->next  n->next;

 

  插入有序链表的函数为：

   功能：插入有序链表的某个节点的后面（从小到大）

   返回：指向链表表头的指针

struct student *SortInSert(struct student *head,struct student *node)

{

            struct student *p;  //p保存当前需要检查的节点的地址

             struct student *t ;//临时指针变量

               if(head==NULL)

               {

                        head=node;

                         node->next=NULL;

                        n+=1;

                        return head;

              }

                p=head;

                 while(p->num<node->num&&p!=NULL)

                {

                            t=p;

                            p=p->next;

               }

                 if(p==head)

                {

                        node->next=p;

                         head=node;

               }

               else

              {

                             t->next=node;

                            node->next=p;

              }

               n+=1;

               return head;

 

 

 

 

 

}

 

 

 

 

 

 

 

 

 

 





nanjoh
关注
专栏目录
链表各类操作详解
WangY.H
07-07 570
链表概述 　　 链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”，每个结点都应包括两个部分：一为用户需要用的实际数据，二为下一个结点的地址。因此，head指向第一个元素：第一个元素又指向第二个元素；……，直到最后一个元素，该元素不再指向其它元素，它...
C语言基础入门：链表详解篇
C语言C++学习俱乐部：765860056
11-24 2815
链表概述 　　链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”，每个结点都应包括两个部分： 一为用户需要用的实际数据，二为下一个结点的地址。因此，head指向第一个元素：第一个元素又指向第二个元素;……，直到最后一个元素，该元素不再指向其它元素，它称为“表尾”，它的地址部分放一个“NULL”(表示“空地址”)，链表到此结束。 　　链表的各类操.
链表的实现
moses1213的专栏
01-07 398
编程初学者，记录学习过程。1.单链表的实现：#include #include #include struct node { ElemtType Element; Position Next; }; list makeEmpty(list L) { if(L != NULL) deleteList(L); L = malloc( sizeof( s
数据结构——链表
最新发布
2301_80373479的博客
08-13 1801
轻松无痛玩转链表
单链表的各种操作
qq_42719683的博客
08-04 145
今日任务：单链表的学习 链表的定义： struct linklist { int date; struct *linklist; }; 链表的初始化（带头结点）： int linklistinit(LINK *list) { list=(LINK *list)malloc(sizeof(LINK)); list-&gt;next =NULL; } ...
面试官：说说你对链表的理解？常见的操作有哪些？
weixin_44475093的博客
09-24 260
一、是什么链表（Linked List）是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的，由一系列结点（链表中每一个元素称为结点）组成每个结...
链表的常见操作
让你爱上电路设计
05-12 243
链表的常见操作
深入理解链表的各类操作详解
01-20
了解并熟练掌握链表的这些操作是编程基础的重要组成部分，特别是在处理动态数据集时，链表能够提供高效且灵活的数据管理方案。在实际应用中，链表常用于实现各种高级数据结构，如队列、栈、哈希表等。
Python链表操作详解：掌握单双向链表构建与高效应用
[Python链表操作详解：掌握单双向链表构建与高效应用](https://media.geeksforgeeks.org/wp-content/uploads/20230817151337/1.png) # 1. Python链表基础概念解析 Python作为一种高级编程语言，虽然没有内置的链表...
常见的链表操作
zlx_code的专栏
03-14 416
一、单链表 单链表的操作主要包括：链表数据插入、删除节点，以及一些衍生的单链表的翻转、检测链表中的环、两个有序链表的合并、删除倒数第n个节点和求链表的中间节点。 首先是单链表的基本操作：链表的插入，在这里使用的是头插法，并且添加了哨兵节点，也就是头结点，这样可以不用考虑头结点的边界问题，具体C++代码如下： 1、链表的插入 struct SingleLi...
关于链表的一些操作总结
一个简单的故事
10-03 735
链表反转 这是一个简单的链表操作问题，在leetcode上面有52.7%的通过率，难度是简单。但是还是想在这里基于python做一下总结，顺便总结一下链表的各种操作。 首先先看一下leetcode上面的题目： 反转一个单链表。 示例: 输入: 1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;NULL 输出: 5-&gt;4-&gt;3-&gt;2-&gt;1-&gt;NULL 进阶:...
链表的常见操作入门（一）
让你一生残梦的博客
09-08 635
链表的建立：       一般采用结构体指针，建立如下： struct node { int data; struct node *next; } 链表的头文件： #include&lt;stdlib&gt; 链表基本模板：  （1）链表建立： struct node { int m; struct node *next; }*p,*...
5个常见的链表操作
wzw的博客
06-08 292
1.单链表反转 LeetCode对应题目 https://leetcode-cn.com/problems/reverse-linked-list/ 比较适合用头插法，大致思路就是： 首先判断这个参数是不是Null,如果是的话，那就直接返回null，如果不是的话，开始正常操作:.创建三个新的结点，其中一个当做新的头结点，一个指向原来的头结点，另一个起辅助作用。然后开始遍历，在原来结点还存在的情况之下，开始不断地断开和头插。 if(NULL == head) return NULL
链表八大操作
小明同学的博客
12-21 506
** 链表八大操作 2018年12月22日** 以下内容仅供娱乐，欢迎随时探讨，请多指教！ 有如下的结构体： typedef struct link_list { int num; char sex[20]; char name[30]; struct link_list *next; }STU; 利用此结构体设计单链表，并在单链表上完成如下操作： （1） 创建链表。 （2） 输出...
单链表分析
亡羊补牢
08-18 965
由于单链表是由一个个结点链接而成，所以一下用单链表结点类和单链表类描述单链表          1.单链表结点类              采用java语言的引用类型来实现链式存储结构，单链表结点类Node声明如下： package linearList; public class Node {//单链表结点类 public E data;//数据域 public Node next;
数据结构之链表，使用链表实现栈以及使用链表实现队列
HiterCoder
03-07 538
1、结合之前实现的链表这个数据结构，如果只对链表的头部进行增加和删除，时间复杂度是O(1)的，只对链表的头部进行查询的话，时间复杂度是O(1)的。那么，满足这样的数据结构是什么呢，就是栈，栈这种数据结构是后入先出的，或者先进后出的，只对栈的一端，就是栈顶进行操作，无论是添加元素、删除元素、查询元素，都是在栈顶进行的。所以对于链表来说，可以将链表的头部当作栈顶，用链表做为栈的底层实现来实现...
链表操作中的值传递和地址传递
丁哒哒的博客
02-24 1503
今天刷题时，遇到一个问题，链表不都是地址传递，当赋值不是节点时，是值传递，验证如下： 1、地址传递 function ListNode(val) { this.val = val; this.next = null; } let a = new ListNode(1); let b = a; // 引用赋值 console.log(a,b); b.next = new ListNode(2); b = b.next; //节点，引用赋值 console.log(a,b);
链表：操作
qq_44781747的博客
04-03 175
LeetCode707. 设计链表 https://leetcode-cn.com/problems/design-linked-list/ 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的
数据结构实验：链表的插入与删除
comchk的博客
11-22 912
实验1 链表的插入和删除 一、【实验目的】 了解单链表、循环链表和双链表的基本知识； 掌握算法思想和数据结构的描述； 掌握链表的插入、删除的相关语句及基本方法。 二、【实验内容】 设有两个无头结点的单链表，分别为ha，hb，其链中有数据域data，链域next，两链表的数据都按递增序存放。现要求将hb表归到ha表中，且归并后ha仍按递增排序，归并中ha表中已有的数据若与hb相同，则hb中的数据不归并到ha中，hb的链表在算法中不允许破坏。 #include<iostream&
链表数据结构详解：创建、操作与应用
“深入理解链表的各类操作详解” 本文将详细介绍链表这一重要的数据结构，以及如何对其进行各种操作。链表不同于数组，它是一种动态存储分配的数据结构，能够根据需要动态地创建或销毁节点。链表由头指针（head）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值