经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » C 语言 » 查看文章
C语言合并两个带头节点升序排列链表
来源：jb51　　时间：2019/3/4 8:40:12　　对本文有异议

合并链表，顾名思义，就是将两个按顺序存放数据的链表中的数据合并为用一个链表存储，比如在处理多项式的加减法时就需要将两个多项式的数据进行合并。合并方式有很多种：如果按照存储方式的不同，可以将两个链表的数据分别提取出来生成一个新的链表来存储原先两个链表的数据，还可以将其中一个链表的数据依次插入到另外一个链表的相应位置当中去。在遇到相同数据时可以采取只留下一个数据的方式和两个数据均保留的方式。这些不同点需要到具体的问题中具体分析，但是只是在细节上有一些差别，大体的思路都是一样的，本文主要介绍将一个链表插入到另一个链表的相应位置，插入完成后销毁链表二，且遇到相同数据采用均保留的方式。

我们还是先抛开链表的操作本身，先对两组不同的数据进行合并操作，知道两组按升序排列的数据该如何合并成一组数据，我们来分析这样几组数据（将第二组的数据插入到第一组中）：

1   5   9   13   15

2   7   12

对于这组数据我们可以很轻易的说出应该把“2”插入到“1”的前面，应该把“7”插入到“5”的前面... ... 那么我们又是如何得到这个结论的呢，接下来我们来用语言细致的描述一下我们刚才是如何得到这样的结论的：“首先，遍历第一组数据，找到第一个比要插入的数据大的数据的前一个数据“i”，再将要插入的数据插入到“i”的后面”。

上述描述解决了插入数据的一般性情况，包括我们用“比该数据大”这样的话说明了遇到相同数据时该如何处理，但是，问题依然存在，我们来观察下面一组数据：

2   4   7   9

1   3   6   8

我们要将第二组数据插入到第一组数据中，按照之前的说法，找到第一个不比待插入数据小的数据的前一个数据“i”，但是我们发现第一组数据中第一个数据就符合我们的要求，那么它自然没有前一个数据。这里我们给出一个方案：在进行插入工作前，先对两个链表的首元素进行比较，如果链表一的首元素是小于第二个链表的首元素的，那么开始合并工作，如果链表一的首元素不小于第二个链表的首元素，我们先交换两个链表的头结点，使得链表一变成链表二。但是这种方式仅适用于我们当前的情况，因为我们要实现的是将链表二的元素加入到链表一中，之后销毁链表二，这就意味着我们最后只要得到一个链表就可以，只要使得传递过来的链表一在执行完我们的合并链表程序后能够变成合并后的结果链表就好了，因此我们可能要更改传递过来的链表的头结点的值。

根据上面的说法，我们就要在开始进行合并之前先对两个链表的首元素进行比较，如果链表二的首元素比链表一的首元素大，则交换两个链表的控制头，再执行后续的合并工作。

解决了上述问题，还差最后一种情况，我们来观察下面一组数据：

1   3   4   6   7

2   6   9   10  13

我们可以观察到，将第二组数据依次向第一组数据中插入，到了“9”的时候，第一组数据就没有可以插入的位置了，而应该在尾部追加，于是，我们就不能执行之前的操作了，而应该执行另外一项操作，我们具体实现是这样的：

如果我们在第一组数据中找不到比待插入数据大的数据，我们就将待插入数据的后面的数据连同待插入数据本身，追加到第一组数据的末尾。

根据如上分析，我们需要执行的有四种对链表的操作：1、在指定链中找到第一个比目标数据的大的节点的前驱节点； 2、将指定元素插入到指定链表的指定位置； 3、将链表中的制定位置后的所有元素追加到指定链表的末尾； 4、交换两个链表的头结点。

下面我们就分布解决这四种操作（注：A_LINE是我们自己定义的为了方便起见的一个结构体，只有一个int类型的num和一个A_LINE *类型的next成员不具有任何意义，仅仅是为了完成合并链表）：

1、在指定链中找到第一个比目标数据的大的节点的前驱节点：

  1. A_LINE *getFirstLocalBiggerThanEle(A_LINE head, A_LINE ele) {
  2.  A_LINE *p;
  3.  A_LINE *q;
  4.  
  5.  for (p = head.next; p->next != NULL && ele.num >= p->num; p = p->next)
  6.  q = p;
  7.  if (p->next == NULL) {
  8.  return NOT_FOUND;
  9.  }
  10.  return q;
  11. }
  12.  

我们用A_LINE *p来遍历链表一，用A_LINE *q来实时保存当前节点的前驱节点，链表没有遍历完而且当前元素依然小于等于目标元素，则循环继续。当循环结束后，判断循环结束的原因，如果是因为链表遍历完了而结束的循环，则说明整个链表里都没有比目标节点大的节点，返回NOT_FOUND;若是因为找到了比目标元素大的元素而结束的，那么返回该元素的前驱节点的地址“q”。

2、将指定元素插入到指定链表的指定位置：

  1. void insertEleToLine(A_LINE *local, A_LINE ele) {
  2.  A_LINE *newEle;
  3.  
  4.  newEle = (A_LINE *)calloc(1, sizeof(A_LINE));
  5.  newEle->next = local->next;
  6.  local->next = newEle;
  7.  newEle->num = ele.num;
  8. }

在第一步中我们已经可以得到需要插入的位置的首地址了，下一步我们就要完成插入了，这对于学过链表的人并不是什么难事，本文不做为重点讲解。

3、将一段数据追加到指定链表的末尾：

  1. void appendLineToLineEnd(A_LINE *line, A_LINE targetLine) {
  2.  A_LINE *tarP;
  3.  
  4.  for (tarP = targetLine.next; tarP->next != NULL; tarP = tarP->next)
  5.  ;
  6.  tarP->next = line;
  7. }

这里给出的A_LINE *line代表着待插入链表的首元素的首地址，targetLine代表要插入到的链表的头结点。首先先定位目标链表的末节点的首地址，再将待插入链表的末节点的next成员更改为待插入链表的首元素的首地址。

但这里存在着问题，这里的赋值相当于直接把链表二的一部分节点直接放到链表一的末尾，并不是复制出来一份再追加到链表一的末尾，这样就使得链表二的那一部分节点又属于链表一又属于链表二，而链表二在最后是要被释放的，那么它的后几个节点也会被释放。为了防止这样的情况发生，我们必须将链表二中的要插入到链表一中的那一部分节点的前驱节点的next成员赋值为NULL，这样在就相当于将那一部分节点从链表二中删除，但是这样并不会引起内存泄漏，这些节点被连接到了链表一的末尾，因此在释放链表一的时候这些节点依然会被释放。

4、交换两个链表的头结点：

  1. void exchangeLine(A_LINE *head1, A_LINE *head2) {
  2.  A_LINE temp;
  3.  
  4.  temp = *head1;
  5.  *head1 = *head2;
  6.  *head2 = temp;
  7. }

5、合并链表完整代码：

  1. void margeLine(A_LINE *targetLine, A_LINE *resourceLine) {
  2.  A_LINE *tarP = targetLine->next;
  3.  A_LINE *srcP = resourceLine->next;
  4.  A_LINE *srcPreP;
  5.  A_LINE *local;
  6.  
  7.  if (tarP->num >= srcP->num) {
  8.  exchangeLine(targetLine, resourceLine);
  9.  }
  10.  
  11.  for (srcP = srcPreP = resourceLine->next; srcP != NULL; srcP = srcP->next) {
  12.  local = getFirstLocalBiggerThanEle(*targetLine, *srcP);
  13.  
  14.  if (local != NOT_FOUND) {
  15.  insertEleToLine(local, *srcP);
  16.  }
  17.  else {
  18.  appendLineToLineEnd(srcPreP->next, *targetLine);
  19.  srcPreP->next = NULL;
  20.  destoryLine(resourceLine);
  21.  return;
  22.  }
  23.  srcPreP = srcP;
  24.  }
  25.  destoryLine(resourceLine);
  26. }

最后我们给出整体的可测试的代码：

  1. #include<stdio.h>
  2. #include<malloc.h>
  3.  
  4. #define NOT_FOUND NULL
  5.  
  6. typedef struct A_LINE {
  7.  int num;
  8.  struct A_LINE *next;
  9. } A_LINE;
  10.  
  11. void margeLine(A_LINE *targetLine, A_LINE *resourceLine);
  12. A_LINE *getFirstLocalBiggerThanEle(A_LINE head, A_LINE ele);
  13. void insertEleToLine(A_LINE *local, A_LINE ele);
  14. void destoryLine(A_LINE *head);
  15. void initLine(A_LINE *head);
  16. void showLine(A_LINE head);
  17. void exchangeLine(A_LINE *head1, A_LINE *head2);
  18. void appendLineToLineEnd(A_LINE *line, A_LINE targetLine);
  19.  
  20. void appendLineToLineEnd(A_LINE *line, A_LINE targetLine) {
  21.  A_LINE *tarP;
  22.  
  23.  for (tarP = targetLine.next; tarP->next != NULL; tarP = tarP->next)
  24.  ;
  25.  tarP->next = line;
  26. }
  27.  
  28. void exchangeLine(A_LINE *head1, A_LINE *head2) {
  29.  A_LINE temp;
  30.  
  31.  temp = *head1;
  32.  *head1 = *head2;
  33.  *head2 = temp;
  34. }
  35.  
  36. void showLine(A_LINE head) {
  37.  A_LINE *p;
  38.  
  39.  for (p = head.next; p != NULL; p = p->next) {
  40.  printf("%d ", p->num);
  41.  }
  42. }
  43.  
  44. void initLine(A_LINE *head) {
  45.  int num;
  46.  A_LINE *p = NULL;
  47.  
  48.  printf("请输入一个数（-1表示结束）：");
  49.  scanf_s("%d", &num);
  50.  while (num != -1) {
  51.  if (head->next == NULL) {
  52.  head->next = (A_LINE *)calloc(1, sizeof(A_LINE));
  53.  (head->next)->num = num;
  54.  p = head->next;
  55.  }
  56.  else {
  57.  p->next = (A_LINE *)calloc(1, sizeof(A_LINE));
  58.  (p->next)->num = num;
  59.  p = p->next;
  60.  }
  61.  printf("请输入一个数（-1表示结束）");
  62.  scanf_s("%d", &num);
  63.  }
  64. }
  65.  
  66. void destoryLine(A_LINE *head) {
  67.  A_LINE *p = head->next;
  68.  
  69.  while (NULL != head->next) {
  70.  p = head->next;
  71.  head->next = p->next;
  72.  free(p);
  73.  }
  74. }
  75.  
  76. void insertEleToLine(A_LINE *local, A_LINE ele) {
  77.  A_LINE *newEle;
  78.  
  79.  newEle = (A_LINE *)calloc(1, sizeof(A_LINE));
  80.  newEle->next = local->next;
  81.  local->next = newEle;
  82.  newEle->num = ele.num;
  83. }
  84.  
  85. A_LINE *getFirstLocalBiggerThanEle(A_LINE head, A_LINE ele) {
  86.  A_LINE *p = NULL;
  87.  A_LINE *q = NULL;
  88.  
  89.  for (p = head.next; p != NULL && ele.num >= p->num; p = p->next)
  90.  q = p;
  91.  if (p == NULL) {
  92.  return NOT_FOUND;
  93.  }
  94.  return q;
  95. }
  96.  
  97. void margeLine(A_LINE *targetLine, A_LINE *resourceLine) {
  98.  A_LINE *tarP = targetLine->next;
  99.  A_LINE *srcP = resourceLine->next;
  100.  A_LINE *srcPreP;
  101.  A_LINE *local;
  102.  
  103.  if (tarP->num >= srcP->num) {
  104.  exchangeLine(targetLine, resourceLine);
  105.  }
  106.  
  107.  for (srcP = srcPreP = resourceLine->next; srcP != NULL; srcP = srcP->next) {
  108.  local = getFirstLocalBiggerThanEle(*targetLine, *srcP);
  109.  
  110.  if (local != NOT_FOUND) {
  111.  insertEleToLine(local, *srcP);
  112.  }
  113.  else {
  114.  appendLineToLineEnd(srcPreP->next, *targetLine);
  115.  srcPreP->next = NULL;
  116.  destoryLine(resourceLine);
  117.  return;
  118.  }
  119.  srcPreP = srcP;
  120.  }
  121.  destoryLine(resourceLine);
  122. }
  123.  
  124. void main(void) {
  125.  A_LINE head1 = {0};
  126.  A_LINE head2 = {0};
  127.  
  128.  printf("录入第一个链表：\n");
  129.  initLine(&head1);
  130.  printf("录入第二个链表\n");
  131.  initLine(&head2);
  132.  
  133.  margeLine(&head1, &head2);
  134.  
  135.  printf("链表一:\n");
  136.  showLine(head1);
  137.  printf("链表二:\n");
  138.  showLine(head2);
  139.  
  140.   destoryLine(&head1);
  141. }
  142.  
  143.  

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持w3xue。

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

C 语言热门文章

  • 图形学入门(1)——直线生成算法（DDA和Bresenham）
  • 用C语言制作一个最简单的飞机游戏！
  • MODBUS 超时时间计算
  • zabbix wait for 15s seconds 出现原因及调优建议
  • C/C++知识分享：assert()函数
  • 图形学入门(2)——圆弧生成算法（中点画圆法）
  • C 共享内存封装
  • C语言中break与continue的用法和区别详解
  • GStreamer基础教程09 - Appsrc及Appsink
  • 三元组矩阵行列式的计算（用递归）

    • C 语言推荐文章

  • C语言指针易混淆知识点总结
  • 进程间通信
  • 数组降维、函数栈帧、地址空间、可变参数原理剖析
  • 【Learning eBPF-3】一个 eBPF 程序的深入剖析
  • [apue] 进程控制那些事儿
  • 解密C语言选择结构：掌握条件语句与分支逻辑的利器
  • 精通C语言：打造高效便捷的通讯录管理系统
  • c语言实现内存池
  • [数据结构] 数组与特殊矩阵
  • 探索C语言结构体：编程中的利器与艺术

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号