玩转C语言链表

  链表概述

  链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量,以head表示,它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”,每个结点都应包括两个部分:一为用户需要用的实际数据,二为下一个结点的地址。因此,head指向第一个元素:第一个元素又指向第二个元素;……,直到最后一个元素,该元素不再指向其它元素,它称为“表尾”,它的地址部分放一个“NULL”(表示“空地址”),链表到此结束。

  链表的各类操作包括:学习单向链表的创建、删除、 插入(无序、有序)、输出、 排序(选择、插入、冒泡)、反序等等。

  单向链表的图示:

  ---->[NULL]

  head

  复制代码

  图1:空链表

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

  head p1->next p2->next pn->next

  复制代码

  图2:有N个节点的链表

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

  #include "stdlib.h"

  #include "stdio.h"

  #define NULL 0

  #define LEN sizeof(struct student)

  struct student

  {

  int num; //学号

  float score; //分数,其他信息可以继续在下面增加字段

  struct student *next; //指向下一节点的指针

  };

  int n; //节点总数

  /*

  ==========================

  功能:创建n个节点的链表

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

  ==========================

  */

  struct student *Create()

  {

  struct student *head; //头节点

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

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

  n = 0; //创建前链表的节点总数为0:空链表

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

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

  IF(p1==NULL) //节点开辟不成功

  {

  printf ("\nCann‘t create it, try it again in a moment!\n");

  return NULL;

  }

  else //节点开辟成功

  {

  head = NULL; //开始head指向NULL

  printf ("Please input %d node -- num,score: ", n + 1);

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

  }

  while(p1->num != 0) //只要学号不为0,就继续录入下一个节点

  {

  n += 1; //节点总数增加1个

  if(n == 1) //如果节点总数是1,则head指向刚创建的节点p1

  {

  head = p1;

  p2->next = NULL; //此时的p2就是p1,也就是p1->next指向NULL。

  }

  else

  {

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

  }

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

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

  printf ("Please input %d node -- num,score: ", n + 1);

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

  }

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

  free(p1); //p1->num为0的时候跳出了while循环,并且释放p1

  p1 = NULL; //特别不要忘记把释放的变量清空置为NULL,否则就变成"野指针",即地址不确定的指针

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

  }

  复制代码

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

  /*

  ===========================

  功能:输出节点

  返回: void

  ===========================

  */

  void Print(struct student *head)

  {

  struct student *p;

  printf ("\nNow , These %d records are:\n", n);

  p = head;

  if(head != NULL) //只要不是空链表,就输出链表中所有节点

  {

  printf("head is %o\n", head); //输出头指针指向的地址

  do

  {

  /*

  输出相应的值:当前节点地址、各字段值、当前节点的下一节点地址。

  这样输出便于读者形象看到一个单向链表在计算机中的存储结构,和我们

  设计的图示是一模一样的。

  */

  printf ("%o %d %5.1f %o\n", p, p->num, p->score, p->next);

  p = p->next; //移到下一个节点

  }

  while (p != NULL);

  }

  }

  复制代码

  单向链表的删除图示:

  ---->[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。

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

  /*

  ==========================

  功能:删除指定节点

  (此例中是删除指定学号的节点)

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

  ==========================

  */

  struct student *Del (struct student *head, int num)

  {

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

  struct student *p2; //p2保存当前检查过的节点的地址

  if (head == NULL) //是空链表(结合图3理解)

  {

  printf ("\nList is null!\n");

  return head;

  }

  //定位要删除的节点

  p1 = head;

  while (p1->num != num && p1->next != NULL) //p1指向的节点不是所要查找的,并且它不是最后一个节点,就继续往下找

  {

  p2 = p1; //保存当前节点的地址

  p1 = p1->next; //后移一个节点

  }

  if(p1->num==num) //找到了。(结合图4、5理解)

  {

  if (p1 == head) //如果要删除的节点是第一个节点

  {

  head = p1->next; //头指针指向第一个节点的后一个节点,也就是第二个节点。这样第一个节点就不在链表中,即删除

  }

  else //如果是其它节点,则让原来指向当前节点的指针,指向它的下一个节点,完成删除

  {

  p2->next = p1->next;

  }

  free (p1); //释放当前节点

  p1 = NULL;

  printf ("\ndelete %ld success!\n", num);

  n -= 1; //节点总数减1个

  }

  else //没有找到

  {

  printf ("\n%ld not been found!\n", num);

  }

  return head;

  }

  复制代码

  单向链表的插入图示:

  ---->[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。

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

  /*

  ==========================

  功能:插入指定节点的后面

  (此例中是指定学号的节点)

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

  ==========================

  */

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

  {

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

  if (head == NULL) //(结合图示7理解)

  {

  head = node;

  node->next = NULL;

  n += 1;

  return head;

  }

  p1 = head;

  while(p1->num != num && p1->next != NULL) //p1指向的节点不是所要查找的,并且它不是最后一个节点,继续往下找

  {

  p1 = p1->next; //后移一个节点

  }

  if (p1->num==num) //找到了(结合图示8理解)

  {

  node->next = p1->next; //显然node的下一节点是原p1的next

  p1->next = node; //插入后,原p1的下一节点就是要插入的node

  n += 1; //节点总数增加1个

  }

  else

  {

  printf ("\n%ld not been found!\n", num);

  }

  return head;

  }

  复制代码

  单向链表的反序图示:

  ---->[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。

  反序链表的函数为:

  /*

  ==========================

  功能:反序节点

  (链表的头变成链表的尾,链表的尾变成头)

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

  ==========================

  */

  struct student *Reverse (struct student *head)

  {

  struct student *p; //临时存储

  struct student *p1; //存储返回结果

  struct student *p2; //源结果节点一个一个取

  p1 = NULL; //开始颠倒时,已颠倒的部分为空

  p2 = head; //p2指向链表的头节点

  while(p2 != NULL)

  {

  p = p2->next;

  p2->next = p1;

  p1 = p2;

  p2 = p;

  }

  head = p1;

  return head;

  }

  复制代码

  对链表进行选择排序的基本思想就是反复从还未排好序的那些节点中,选出键值(就是用它排序的字段,我们取学号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,然后它变成其尾指针;

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

  ==========================

  */

  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语句就是体现选择排序思想的地方

  for (p = head, min = head; p->next != NULL; p = p->next) //循环遍历链表中的节点,找出此时最小的节点

  {

  if (p->next->num < min->num) //找到一个比当前min小的节点

  {

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

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

  }

  }

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

  //第一件事

  if (first == NULL) //如果有序链表目前还是一个空链表

  {

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

  tail = min; //注意:尾指针让它指向最后的一个节点

  }

  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个节点是已经按键值(就是用它排序的字段,我们取学号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罢了。

  这一点请读者务必搞清楚,要不然就可能认为它和上面的选择排序法一样了。

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

  /*

  ==========================

  功能:直接插入排序(由小到大)

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

  ==========================

  */

  struct student *InsertSort (struct student *head)

  {

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

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

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

  first = head->next; //原链表剩下用于直接插入排序的节点链表:可根据图12来理解

  head->next = NULL; //只含有一个节点的链表的有序链表:可根据图11来理解

  while(first != NULL) //遍历剩下无序的链表

  {

  //注意:这里for语句就是体现直接插入排序思想的地方

  for (t = first, q = head; ((q != NULL) && (q->num < t->num)); p = q, q = q->next); //无序节点在有序链表中找插入的位置

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

  //注意:按道理来说,这句话可以放到下面注释了的那个位置也应该对的,但是就是不能。原因:你若理解了上面的第3条,就知道了

  //下面的插入就是将t节点即是first节点插入到p节点之后,已经改变了first节点,所以first节点应该在被修改之前往后移动,不能放到下面注释的位置上去

  first = first->next; //无序链表中的节点离开,以便它插入到有序链表中

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

  {

  head = t;

  }

  else //p是q的前驱

  {

  p->next = t;

  }

  t->next = q; //完成插入动作

  //first = first->next;

  }

  return head;

  }

  复制代码

  对链表进行冒泡排序的基本思想就是对当前还未排好序的范围内的全部节点,自上而下对相邻的两个节点依次进行比较和调整,让键值(就是用它排 序的字段,我们取学号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、下面的程序描述改进了一点就是记录了每次最后一次节点下沉的位置,这样我们不必每次都从头到尾的扫描,只需要扫描到记录点为止。 因为后面的都已经是排好序的了。

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

  /*

  ==========================

  功能:冒泡排序(由小到大)

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

  ==========================

  */

  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; //让head指向p1节点,排序完成后,我们再把p1节点释放掉

  for (endpt = NULL; endpt != head; endpt = p) //结合第6点理解

  {

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

  {

  if (p1->next->num > p1->next->next->num) //如果前面的节点键值比后面节点的键值大,则交换

  {

  p2 = p1->next->next; //结合第1点理解

  p1->next->next = p2->next; //结合第2点理解

  p2->next = p1->next; //结合第3点理解

  p1->next = p2; //结合第4点理解

  p = p1->next->next; //结合第6点理解

  }

  }

  }

  p1 = head; //把p1的信息去掉

  head = head->next; //让head指向排序后的第一个节点

  free (p1); //释放p1

  p1 = NULL; //p1置为NULL,保证不产生“野指针”,即地址不确定的指针变量

  return head;

  }

  复制代码

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

  ---->[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

  复制代码

  插入有序链表的函数为:

  /*

  ==========================

  功能:插入有序链表的某个节点的后面(从小到大)

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

  ==========================

  */

  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) //p指向的节点的学号比插入节点的学号小,并且它不等于NULL

  {

  t = p; //保存当前节点的前驱,以便后面判断后处理

  p = p->next; //后移一个节点

  }

  if (p == head) //刚好插入第一个节点之前

  {

  node->next = p;

  head = node;

  }

  else //插入其它节点之后

  {

  t->next = node; //把node节点加进去

  node->next = p;

  }

  n += 1; //插入完毕,节点总数加1

  return head;

  }

  复制代码

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

  #include "stdlib.h"

  #include "stdio.h"

  #define NULL 0

  #define LEN sizeof(struct student)

  struct student

  {

  int num; //学号

  float score; //分数,其他信息可以继续在下面增加字段

  struct student *next; //指向下一节点的指针

  };

  int n; //节点总数

  /*

  ==========================

  功能:创建n个节点的链表

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

  ==========================

  */

  struct student *Create()

  {

  struct student *head; //头节点

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

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

  n = 0; //创建前链表的节点总数为0:空链表

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

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

  if(p1==NULL) //节点开辟不成功

  {

  printf ("\nCann‘t create it, try it again in a moment!\n");

  return NULL;

  }

  else //节点开辟成功

  {

  head = NULL; //开始head指向NULL

  printf ("Please input %d node -- num,score: ", n + 1);

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

  }

  while(p1->num != 0) //只要学号不为0,就继续录入下一个节点

  {

  n += 1; //节点总数增加1个

  if(n == 1) //如果节点总数是1,则head指向刚创建的节点p1

  {

  head = p1;

  p2->next = NULL; //此时的p2就是p1,也就是p1->next指向NULL。

  }

  else

  {

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

  }

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

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

  printf ("Please input %d node -- num,score: ", n + 1);

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

  }

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

  free(p1); //p1->num为0的时候跳出了while循环,并且释放p1

  p1 = NULL; //特别不要忘记把释放的变量清空置为NULL,否则就变成"野指针",即地址不确定的指针

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

  }

  /*

  ===========================

  功能:输出节点

  返回: void

  ===========================

  */

  void Print(struct student *head)

  {

  struct student *p;

  printf ("\nNow , These %d records are:\n", n);

  p = head;

  if(head != NULL) //只要不是空链表,就输出链表中所有节点

  {

  printf("head is %o\n", head); //输出头指针指向的地址

  do

  {

  /*

  输出相应的值:当前节点地址、各字段值、当前节点的下一节点地址。

  这样输出便于读者形象看到一个单向链表在计算机中的存储结构,和我们

  设计的图示是一模一样的。

  */

  printf ("%o %d %5.1f %o\n", p, p->num, p->score, p->next);

  p = p->next; //移到下一个节点

  }

  while (p != NULL);

  }

  }

  /*

  ==========================

  功能:删除指定节点

  (此例中是删除指定学号的节点)

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

  ==========================

  */

  struct student *Del (struct student *head, int num)

  {

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

  struct student *p2; //p2保存当前检查过的节点的地址

  if (head == NULL) //是空链表(结合图3理解)

  {

  printf ("\nList is null!\n");

  return head;

  }

  //定位要删除的节点

  p1 = head;

  while (p1->num != num && p1->next != NULL) //p1指向的节点不是所要查找的,并且它不是最后一个节点,就继续往下找

  {

  p2 = p1; //保存当前节点的地址

  p1 = p1->next; //后移一个节点

  }

  if(p1->num==num) //找到了。(结合图4、5理解)

  {

  if (p1 == head) //如果要删除的节点是第一个节点

  {

  head = p1->next; //头指针指向第一个节点的后一个节点,也就是第二个节点。这样第一个节点就不在链表中,即删除

  }

  else //如果是其它节点,则让原来指向当前节点的指针,指向它的下一个节点,完成删除

  {

  p2->next = p1->next;

  }

  free (p1); //释放当前节点

  p1 = NULL;

  printf ("\ndelete %ld success!\n", num);

  n -= 1; //节点总数减1个

  }

  else //没有找到

  {

  printf ("\n%ld not been found!\n", num);

  }

  return head;

  }

  //销毁链表

  void DestroyList(struct student *head)

  {

  struct student *p;

  if(head==NULL)

  return 0;

  while(head)

  {

  p=head->next;

  free(head);

  head=p;

  }

  return 1;

  }

  /*

  ==========================

  功能:插入指定节点的后面

  (此例中是指定学号的节点)

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

  ==========================

  */

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

  {

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

  if (head == NULL) //(结合图示7理解)

  {

  head = node;

  node->next = NULL;

  n += 1;

  return head;

  }

  p1 = head;

  while(p1->num != num && p1->next != NULL) //p1指向的节点不是所要查找的,并且它不是最后一个节点,继续往下找

  {

  p1 = p1->next; //后移一个节点

  }

  if (p1->num==num) //找到了(结合图示8理解)

  {

  node->next = p1->next; //显然node的下一节点是原p1的next

  p1->next = node; //插入后,原p1的下一节点就是要插入的node

  n += 1; //节点总数增加1个

  }

  else

  {

  printf ("\n%ld not been found!\n", num);

  }

  return head;

  }

  /*

  ==========================

  功能:反序节点

  (链表的头变成链表的尾,链表的尾变成头)

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

  ==========================

  */

  struct student *Reverse (struct student *head)

  {

  struct student *p; //临时存储

  struct student *p1; //存储返回结果

  struct student *p2; //源结果节点一个一个取

  p1 = NULL; //开始颠倒时,已颠倒的部分为空

  p2 = head; //p2指向链表的头节点

  while(p2 != NULL)

  {

  p = p2->next;

  p2->next = p1;

  p1 = p2;

  p2 = p;

  }

  head = p1;

  return head;

  }

  /*

  ==========================

  功能:选择排序(由小到大)

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

  ==========================

  */

  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语句就是体现选择排序思想的地方

  for (p = head, min = head; p->next != NULL; p = p->next) //循环遍历链表中的节点,找出此时最小的节点

  {

  if (p->next->num < min->num) //找到一个比当前min小的节点

  {

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

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

  }

  }

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

  //第一件事

  if (first == NULL) //如果有序链表目前还是一个空链表

  {

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

  tail = min; //注意:尾指针让它指向最后的一个节点

  }

  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;

  }

  /*

  ==========================

  功能:直接插入排序(由小到大)

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

  ==========================

  */

  struct student *InsertSort (struct student *head)

  {

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

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

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

  first = head->next; //原链表剩下用于直接插入排序的节点链表:可根据图12来理解

  head->next = NULL; //只含有一个节点的链表的有序链表:可根据图11来理解

  while(first != NULL) //遍历剩下无序的链表

  {

  //注意:这里for语句就是体现直接插入排序思想的地方

  for (t = first, q = head; ((q != NULL) && (q->num < t->num)); p = q, q = q->next); //无序节点在有序链表中找插入的位置

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

  //注意:按道理来说,这句话可以放到下面注释了的那个位置也应该对的,但是就是不能。原因:你若理解了上面的第3条,就知道了

  //下面的插入就是将t节点即是first节点插入到p节点之后,已经改变了first节点,所以first节点应该在被修改之前往后移动,不能放到下面注释的位置上去

  first = first->next; //无序链表中的节点离开,以便它插入到有序链表中

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

  {

  head = t;

  }

  else //p是q的前驱

  {

  p->next = t;

  }

  t->next = q; //完成插入动作

  //first = first->next;

  }

  return head;

  }

  /*

  ==========================

  功能:冒泡排序(由小到大)

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

  ==========================

  */

  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; //让head指向p1节点,排序完成后,我们再把p1节点释放掉

  for (endpt = NULL; endpt != head; endpt = p) //结合第6点理解

  {

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

  {

  if (p1->next->num > p1->next->next->num) //如果前面的节点键值比后面节点的键值大,则交换

  {

  p2 = p1->next->next; //结合第1点理解

  p1->next->next = p2->next; //结合第2点理解

  p2->next = p1->next; //结合第3点理解

  p1->next = p2; //结合第4点理解

  p = p1->next->next; //结合第6点理解

  }

  }

  }

  p1 = head; //把p1的信息去掉

  head = head->next; //让head指向排序后的第一个节点

  free (p1); //释放p1

  p1 = NULL; //p1置为NULL,保证不产生“野指针”,即地址不确定的指针变量

  return head;

  }

  /*

  ==========================

  功能:插入有序链表的某个节点的后面(从小到大)

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

  ==========================

  */

  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) //p指向的节点的学号比插入节点的学号小,并且它不等于NULL

  {

  t = p; //保存当前节点的前驱,以便后面判断后处理

  p = p->next; //后移一个节点

  }

  if (p == head) //刚好插入第一个节点之前

  {

  node->next = p;

  head = node;

  }

  else //插入其它节点之后

  {

  t->next = node; //把node节点加进去

  node->next = p;

  }

  n += 1; //插入完毕,节点总数加1

  return head;

  }

  /*

  以上函数的测试程序:

  提示:根据测试函数的不同注释相应的程序段,这也是一种测试方法。

  */

  int main(void)

  {

  struct student *head;

  struct student *stu;

  int thenumber;

  // 测试Create()、Print()

  head = Create();

  Print(head);

  //测试Del()

  printf("\nWhich one delete: ");

  scanf("%d",&thenumber);

  head = Del(head,thenumber);

  Print(head);

  //测试Insert()

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

  printf("\nPlease input insert node -- num,score: ");

  scanf("%d %f",&stu->num,&stu->score);

  printf("\nInsert behind num: ");

  scanf("%d",&thenumber);

  head = Insert(head,thenumber,stu);

  Print(head);

  //测试Reverse()

  printf("\nReverse the LinkList: \n");

  head = Reverse(head);

  Print(head);

  //测试SelectSort()

  printf("\nSelectSort the LinkList: \n");

  head = SelectSort(head);

  Print(head);

  //测试InsertSort()

  printf("\nInsertSort the LinkList: \n");

  head = InsertSort(head);

  Print(head);

  //测试BubbleSort()

  printf("\nBubbleSort the LinkList: \n");

  head = BubbleSort(head);

  Print(head);

  printf("\nSortInsert the LinkList: \n");

  //测试SortInsert():上面创建链表,输入节点时请注意学号num从小到大的顺序

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

  printf("\nPlease input insert node -- num,score: ");

  scanf("%d %f",&stu->num,&stu->score);

  head = SortInsert(head,stu);

  Print(head);

  //销毁链表

  DestroyList(head);

  printf ("\n");

  system ("pause");

  }

最后也为大家提供一些链表的参考资料供学习参考

http://www.makeru.com.cn/live/1392_338.html?s=45051

原文地址:https://www.cnblogs.com/8734ujn/p/11648140.html

时间: 2024-10-04 19:37:21

玩转C语言链表的相关文章

C语言链表实例--玩转链表

下图为最一简单链表的示意图: 第 0 个结点称为头结点,它存放有第一个结点的首地址,它没有数据,只是一个指针变量.以下的每个结点都分为两个域,一个是数据域,存放各种实际的数据,如学号 num,姓名 name,性别 sex 和成绩 score 等.另一个域为指针域,存放下一结点的首地址.链表中的每一个结点都是同一种结构类型. 指针域: 即在结点结构中定义一个成员项用来存放下一结点的首地址,这个用于存放地址的成员,常把它称为指针域. 在第一个结点的指针域内存入第二个结点的首地址,在第二个结点的指针域

C语言-链表

单向链表:结构体非常适合链表结构,链表的组成:head指针.数据块节点指针p->nest.结束指针NULL. 链表操作:需要首先找到表头head指针.链表的操作包括动态链表的创建.顺序输出.删除节点.插入节点的操作. 动态存储操作函数:(ANSI规则返回的指针类型为void*,早期的为字符型指针) 分配一个块:void *malloc(unsigned int size)  //分配成功则返回指向起始地址的指针void * 分配多个块:void *calloc(unsigned n,unsign

关于c语言链表的操作

这几天又讲到链表了,但是又忘记了,所以重新把关于链表的建链表,对链表进行排序,然后是删除,插入,以及遍历等功能..但是最近要考试了,所以没有写成菜单的形式..等考试完了,在进行补充吧.. 代码如下... #include<stdio.h> #include<stdlib.h> #include<string.h> struct node { int data; struct node *next; }; int main() { /*建立链表操作*/ int n,x,p

c语言链表和指针的运用

在学习指针之前,首先要认识指针.指针是一个存储计算机内存地址的变量.从指针指向的内存读取数据称作指针的取值.指针可以指向某些具体类型的变量地址,例如int.long和double.指针也可以是void类型.NULL指针和未初始化指针. 根据出现的位置不同,操作符 * 既可以用来声明一个指针变量,也可以用作指针的取值.当用在声明一个变量时,*表示这里声明了一个指针.其它情况用到*表示指针的取值.&是地址操作符,用来引用一个内存地址.通过在变量名字前使用&操作符,我们可以得到该变量的内存地址.

C语言链表的来源分析

C语言中的链表是重点,也是难点,而且意义非凡.对链表的的抽象和恐惧是源于对它的来龙去脉的不明白.所以很有必要对它的发展渊源做透彻分析. 链表的单位是节点,而节点源于复合数据类型:结构体: 节点和结构体的区别就是看是否有指针域,目的就是想找到下一个节点: 结构体形如: struct Ghost { char name[30]; int age; int height; char addr[30]; }; 节点形如: struct Ghost { char name[30]; int age; in

注释最全的C语言链表的增删改查

1 //这是C语言的写法,但会报错,原因是len(当前的节点长度) 2 //无法在insert(插入)和deleted(删除)之后改变 3 //不能使用delete是因为delete是C++中的一个运算符 4 //最终我把改程序用C++写了一遍,运用引用将len的真实值改变了 5 #include <stdio.h> 6 #include <stdlib.h> 7 typedef int ElementType; 8 typedef struct node { 9 ElementT

C语言---链表(包括学习过程中的思想活动)

写链表想法的由来: 链表---重要的数据结构,工作了这么长时间,再也没有写过链表,可能是由于工作中没有使用的原因,也可能是我太懒了,还可能是因为玩游戏玩过头了吧!总之我知道有链表,但是链表是什么好想就天马行空了,所以决定写一下,哈哈,虽然我很菜,但是再菜我也要它跑起来,万一哪天要用那么一下子呢!好了废话不多说,来满足一下自己的小小的一个期望(它跑起来). 特简单的: 首先呢!先码一个特别简单的,主要是为了先了解一下嘛!然后在一点点深入嘛!毕竟这么长时间没有写过了,不是嘛? #include <s

C语言链表

#define _CRT_SECURE_NO_WARNINGS #include "stdio.h" #include "stdlib.h" typedef struct _Teacher { int age; struct _Teacher *next; }Teacher; Teacher* create_teacher(); int print_teacher(Teacher * pHeader); int add_teacher(Teacher * pHead

C语言----------链表的简单操作

#include <stdio.h> #include <malloc.h> typedef struct node{ //定义节点类型 char data; //数据域 struct node *next; //指针域 }linklist; linklist* Create(){ //创建链表 char key; linklist *phead; //头指针 linklist *pnew; //新节点 linklist *pend; //尾指针 phead = (linklist