合并成顺序链表的方法优化（三）

最新推荐文章于 2021-09-23 17:11:01 发布
最新推荐文章于 2021-09-23 17:11:01 发布
阅读量284 收藏
点赞数 1
分类专栏： 数据结构 线性表 文章标签： 数据结构 C语言 链表 合并
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43604992/article/details/84103524
版权

18.11.15

这一次是专门讲链表合并成顺序链表的，是个人对链表合并的一些理解，比较片面，只能参考参考

合并链表的思路

首先，如果我们有两个给定的链表，而且都是乱序的，那么当要我们把它合并成一个顺序链表，我们一开始就想到的思路，便是先将两个链表合并起来，在对合并后的乱序链表进行排序，那就先这么办

在给出程序前先想想 合并&排序函数 该怎么写

合并：非常简单，只需要将第一个链表的最后一个结点的指针，指向第二个链表的第一个结点**（注意不是头结点）**的指针

排序：有点难，我们需要赋给这个函数一个新的链表的头结点地址，然后通过遍历这个乱序链表查找最小（大）值，同时找到的值插入新的链表中，并将找到最小（大）值的那个结点的值改成一个超大（小）值，使其不会再被找到，之后便是反复的遍历乱序列表，最终原来的乱序链表会变成全为超大（小）值的链表，而新的链表的着为排序后的顺序链表

最终代码实现如下：

pNode Find(pNode L,int k){//寻找链表中值为k的结点，将其值改为999
    pNode H;
    H=L->next;
    while(H->data!=k){
        H=H->next;
    }
    H->data=999;
    return L;
}


//重点在这里
pNode Merge(pNode A,pNode B,pNode S){//传入A,B链表，合并为S链表
    int i,k;
    pNode H1=A;
    pNode H;
    while(H1->next!=NULL){
        H1=H1->next;
    }
    H1->next=B->next;
    //以上为A,B链表合并，思路是将定位指针H1不断向后指，
    //直到指到链表尾部，再将B链表的第一个结点的地址赋给H1->next
    //此时链表A就是合并后的链表



    H=A;//定位指针H，用于查找最小值
    while(ListLength(S)!=ListLength(A)){
        k=999;
        while(H->next!=NULL){//出了该循环以后，k应该是存有合并后链表A的最小值的
             if(k>=(H->next->data)){
                k=(H->next->data);
            }
            H=H->next;
        }
        printf(" k 在这时是 %d,    ",k);
        NewInsert(S,k);//将k插入到一个空的只有头结点的链表S
        Print(S);


        H=Find(A,k);//这一步很重要！！！
        //将A链表中值为k的那个结点数值更改为一个超大数，这样后面就不会在把他算进去了

    }
    return S;
}

现在想想能不能进一步优化这个算法，首先，如果我们需要自己创造两个链表，然后进行排序，我们是否可以在链表创造的源头进行优化，即生成链表时就将数据顺序排列好，这一点是行的通的，会大大减小合并时的复杂度

插入函数（可直接形成顺序链表）：

先来写插入函数，即每插一个数，就将其与链表中其他数进行比较，最终可直接生成一个顺序链表，经历了不断的失败后，写出代码如下

pNode Insert(pNode L,int elem){
    int status=1;
    pNode p=L;
    pNode pNew=(pNode)malloc(sizeof(Node));

        while(status){
        if(p->next==NULL){//如果p的下一个结点为空，
                //说明elem已经比前面的任何结点的数值都要大了，则在末尾插入elem
            p->next=pNew;
            pNew->data=elem;
            pNew->next=NULL;
            status=0;
        }

        else if((p->next->data)>=elem){//elem遇到比他大的结点就停下来，在他前面进行插入
                pNew->next=p->next;
                p->next=pNew;
                pNew->data=elem;
                status=0;
            }
            p=p->next;
        }
        return L;
}

上面的代码比较难处理的地方是要对插在末尾的结点进行单独处理（应该是我自己出了太多BUG简直要抓狂），现在假设我们得到了两个顺序链表，现在要将其合并

合并函数：

首先，我们已经有两个顺序链表，为了将其合并成一个从大到小排序的链表，我们比较两个链表的第一个结点，一个比较小，一个比较大，将小的结点数值存入S中，并将小的结点指向下一个结点，再将这下一个结点与刚才那个大的结点进行比较，以此往复，最终可以得到一个有序的链表S

代码实现如下

int FrontInsert(pNode L,int e){//前插算法,插入成功返回1，否则返回0
//这个前插函数是配套底下的合并函数使用的
    pNode pNew;
    pNew=(pNode)malloc(sizeof(Node));
    if(pNew){
        pNew->data=e;
        pNew->next=L->next;
        L->next=pNew;
        return 1;
    }
    else
        return 0;
}

pNode CompareMerge(pNode A,pNode B,pNode S){//合并函数
    //通过比较大小来对两个链表进行合并，暂且称之为比较合并函数....
    pNode H1=A;
    pNode H2=B;
    int tmp;//这是一个中间变量，可有可无的，为了看着方便
    while(H1->next&&H2->next){
        if((H1->next->data)<(H2->next->data)){//如果A链表结点比B链表结点数值小，
        //将A链表节点数值存入S中
            tmp=H1->next->data;
            FrontInsert(S,tmp);
            H1=H1->next;
        }
        else if((H1->next->data)>(H2->next->data)){
        //如果B链表结点比A链表结点数值小，
        //将B链表节点数值存入S中
            tmp=H2->next->data;
            FrontInsert(S,tmp);
            H2=H2->next;
        }
        else if((H1->next->data)==(H2->next->data)){//如果相等就存A
            tmp=H1->next->data;
            FrontInsert(S,tmp);
            H1=H1->next;
        }
        printf("此时链表S为： ");
        Print(S);
    }
    //这里已经退出了上面的循环
    if(H1->next==NULL){//如果A链表的结点已经存完了，那就把B的全部存进去
    //反正已经排好序了
            do{
                tmp=H2->next->data;
                FrontInsert(S,tmp);
                H2=H2->next;
                printf("此时链表S为： ");
                Print(S);
            }while(H2->next!=NULL);
    }
    else if(H2->next==NULL){//如果B链表的结点已经存完了，那就把A的全部存进去
    //反正已经排好序了
            do{
                tmp=H1->next->data;
                FrontInsert(S,tmp);
                H1=H1->next;
                printf("此时链表S为： ");
                Print(S);
            }while(H1->next!=NULL);
    }
    return S;
}

效率比较：

上面的比较合并函数，虽然很长，但是效率怎么样呢，通过测试，当两个有30000个结点的链表进行合并时

这是最开始的合并函数花的时间：
在这里插入图片描述

这是后面的比较合并函数花的时间：
在这里插入图片描述
相比之下，采用第二种方案，快了不止是一点啊，所以第二种算法是花空间换时间的一种算法

源程序：

下面给出两种函数的调试程序

第一种：

#include <stdio.h>
#include<stdlib.h>
#include<malloc.h>//包含malloc()和exit()等函数

typedef int Elemtype;//int是Elemtype

typedef struct node{
    Elemtype data;
    struct node *next;
}Node,*pNode;

pNode CLH(void){//创建链表头结点
    pNode L=(pNode)malloc(sizeof(Node));
    if(!L)
        exit(-1);
    L->next=NULL;
    return L;
}

//一个很简单的前插函数
int Insert(pNode L,int e){//前插算法,插入成功返回1，否则返回0
    pNode pNew;
    pNew=(pNode)malloc(sizeof(Node));
    if(pNew){
        pNew->data=e;
        pNew->next=L->next;
        L->next=pNew;
        return 1;
    }
    else
        return 0;
}

int ListLength(pNode L){//求链表函数长度
    //需要定位指针p,以及计数器i
    pNode p=L->next;//设置定位指针
    int i=0;//设置计数器
    while(p){//如果L不为空
        p=p->next;
        i++;
    }
    return i;
}

void Print(pNode L){
    pNode p=L->next;
    while(p){//只要p不为空，我就可以打印
        printf("%d, ",p->data);
        p=p->next;//完事以后不要忘记指向下一个结点
    }
    printf("\n");
}

pNode Find(pNode L,int k){//寻找链表中值为k的结点，将其值改为999
    pNode H;
    H=L->next;
    while(H->data!=k){
        H=H->next;
    }
    H->data=999;
    return L;
}


//重点在这里
pNode Merge(pNode A,pNode B,pNode S){//传入A,B链表，合并为S链表
    int i,k;
    pNode H1=A;
    pNode H;
    while(H1->next!=NULL){
        H1=H1->next;
    }
    H1->next=B->next;
    //以上为A,B链表合并，思路是将定位指针H1不断向后指，
    //直到指到链表尾部，再将B链表的第一个结点的地址赋给H1->next
    //此时链表A就是合并后的链表



    H=A;//定位指针H，用于查找最小值
    while(ListLength(S)!=ListLength(A)){
        k=999;
        while(H->next!=NULL){//出了该循环以后，k应该是存有合并后链表A的最小值的
             if(k>=(H->next->data)){
                k=(H->next->data);
            }
            H=H->next;
        }
        printf(" k 在这时是 %d,    ",k);
        Insert(S,k);//将k插入到一个空的只有头结点的链表S
        Print(S);


        H=Find(A,k);//这一步很重要！！！
        //将A链表中值为k的那个结点数值更改为一个超大数，这样后面就不会在把他算进去了


    }
    return S;
}

int main(){
    pNode L1,L2,S;//S为合并链表，这里只是S的头结点
    int i;
    L1=CLH();
    for(i=1;i<10;i++){
        Insert(L1,i);//在L1中依次插入i
    }
    printf("表一为：\n");
    Print(L1);
    L2=CLH();
    for(i=1;i<10;i++){
        Insert(L2,3*i);//在L2中依次插入3*i
    }
    printf("表二为；\n");
    Print(L2);
    S=CLH();
    printf("开始合并：\n");
    Merge(L1,L2,S);
    printf("\n最终合并成的顺序链表如下：\n");
    Print(S);
}

运行展示：
在这里插入图片描述

第二种：

#include <stdio.h>
#include<stdlib.h>
#include<malloc.h>//包含malloc()和exit()等函数

typedef int Elemtype;//int是Elemtype

typedef struct node{
    Elemtype data;
    struct node *next;
}Node,*pNode;

pNode CLH(void){//创建链表头结点
    pNode L=(pNode)malloc(sizeof(Node));
    if(!L)
        exit(-1);
    L->next=NULL;
    return L;
}

void Print(pNode L){
    pNode p=L->next;
    while(p){//只要p不为空，我就可以打印
        printf("%d, ",p->data);
        p=p->next;//完事以后不要忘记指向下一个结点
    }
    printf("\n");
}

pNode Insert(pNode L,int elem){
    int status=1;
    pNode p=L;
    pNode pNew=(pNode)malloc(sizeof(Node));

        while(status){
        if(p->next==NULL){//如果p的下一个结点为空，
                //说明elem已经比前面的任何结点的数值都要大了，则在末尾插入elem
            p->next=pNew;
            pNew->data=elem;
            pNew->next=NULL;
            status=0;
        }

        else if((p->next->data)>=elem){//elem遇到比他大的结点就停下来，在他前面进行插入
                pNew->next=p->next;
                p->next=pNew;
                pNew->data=elem;
                status=0;
            }
            p=p->next;
        }
        return L;
}

int FrontInsert(pNode L,int e){//前插算法,插入成功返回1，否则返回0
//这个前插函数是配套底下的合并函数使用的
    pNode pNew;
    pNew=(pNode)malloc(sizeof(Node));
    if(pNew){
        pNew->data=e;
        pNew->next=L->next;
        L->next=pNew;
        return 1;
    }
    else
        return 0;
}

pNode CompareMerge(pNode A,pNode B,pNode S){
    //通过比较大小来对两个链表进行合并，暂且称之为比较合并函数....
    pNode H1=A;
    pNode H2=B;
    int tmp;
    while(H1->next&&H2->next){
        if((H1->next->data)<(H2->next->data)){//如果A链表结点比B链表结点数值小，
        //将A链表节点数值存入S中
            tmp=H1->next->data;
            FrontInsert(S,tmp);
            H1=H1->next;
        }
        else if((H1->next->data)>(H2->next->data)){
        //如果B链表结点比A链表结点数值小，
        //将B链表节点数值存入S中
            tmp=H2->next->data;
            FrontInsert(S,tmp);
            H2=H2->next;
        }
        else if((H1->next->data)==(H2->next->data)){//如果相等就存A
            tmp=H1->next->data;
            FrontInsert(S,tmp);
            H1=H1->next;
        }
        printf("此时链表S为： ");
        Print(S);
    }
    //这里已经退出了上面的循环
    if(H1->next==NULL){//如果A链表的结点已经存完了，那就把B的全部存进去
    //反正已经排好序了
            do{
                tmp=H2->next->data;
                FrontInsert(S,tmp);
                H2=H2->next;
                printf("此时链表S为： ");
                Print(S);
            }while(H2->next!=NULL);
    }
    else if(H2->next==NULL){//如果B链表的结点已经存完了，那就把A的全部存进去
    //反正已经排好序了
            do{
                tmp=H1->next->data;
                FrontInsert(S,tmp);
                H1=H1->next;
                printf("此时链表S为： ");
                Print(S);
            }while(H1->next!=NULL);
    }
    return S;
}

int main(){
    int i;
    pNode L1,L2,S;
    L1=CLH();
    L2=CLH();
    S=CLH();
    printf("表一为：\n");
    for(i=1;i<10;i++){
        Insert(L1,i);//在L2中依次插入3*i
    }
    Print(L1);
    printf("表二为：\n");
    for(i=1;i<10;i++){
        Insert(L2,3*i);//在L2中依次插入3*i
    }
    Print(L2);
    CompareMerge(L1,L2,S);
    Print(S);
}

运行展示：
在这里插入图片描述

以上均为个人关于线性链表合并的片面的理解

猪脚三父
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
某强书上习题：合并链表
pipi_lovelygirl的博客
05-07 177
#include <stdio.h> #include <stdlib.h> #define LEN sizeof(struct student) struct student { long num; int score; struct student *next; }; struct student lista,listb; int n,sum=...
LeetCode-21. 合并两个有序链表_JavaScript
weixin_45344430的博客
08-04 750
将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1： 输入：l1 = [1,2,4], l2 = [1,3,4] 输出：[1,1,2,3,4,4] 示例 2： 输入：l1 = [], l2 = [] 输出：[] 示例 3： 输入：l1 = [], l2 = [0] 输出：[0] 提示： 两个链表的节点数目范围是 [0, 50] -100 <= Node.val <= 100 l1 和 l2 均按 非递减顺序 排列 程序.
两个有序链表序列的合并（2019-05-06）
weixin_44772272的博客
05-06 163
//在编写函数的过程中，尽量采用调用函数的形式 #include<stdio.h> #include<stdlib.h> //定义结构体 typedef struct NODE { int data; struct NODE *next; }NODE, *list; //创建链表 void ReviseList(list *s); //输入链表 void ScanList...
两个顺序链表的合并【openjudge】
weixin_30691871的博客
04-27 105
总时间限制:2ms内存限制:1024kB 描述 已知两个线性单链表A和B中的元素以递增有序排列（数据长度和元素由键盘输入），编写算法将A表和B表归并成一个按元素值递增的有序表C，并要求利用原表（即A和B表的）节点空间存储表C。 再输入链之前，先要输入链的长度 样例输入 6 1 3 6 7 12 13 5 -1 3 8 10 15 样例输出 -1 1 3...
4.线性表的合并
weixin_30562507的博客
07-15 90
1 2#include<stdio.h> 3#include<stdlib.h> 4#include<malloc.h> 5 6#defineOK1 7#defineERROR0 8#defineTRUE1 9#defineFALSE0 10 11#defineElemTy...
顺序链表合并
weixin_47779950的博客
11-01 241
#include <iostream> using namespace std; struct listpoint { listpoint * next; int data; }; listpoint* creat_normal_list(int n) { listpoint * end, *head; end = (listpoint*)malloc(sizeof(listpoint)); head = end; for (int i = 0; i < n; i++)
顺序合并两个链表
weixin_45633353的博客
07-28 203
思路1： 创建新链表，同时遍历两个链表，对两个遍历的节点进行对比，谁的值小，就把值小的节点加入到新链表中。然后让此链表结点后移。 如果出现null则退出循环，直接将未遍历完的链表直接加入到新链表中。并返回新的头节点。 代码 class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } public class Solution { public ListNode mergeTw
如何优化C语言代码(程序员必读)
01-02
将比较慢的顺序查找法用较快的二分查找或乱序查找法代替，插入排序或冒泡排序法用快速排序、合并排序或根排序代替，都可以大大提高程序执行的效率。.选择一种合适的数据结构也很重要，比如你在一堆随机存放的数中...
如何优化单片机C语言代码
08-18
将比较慢的顺序查找法用较快的二分查找或乱序查找 法代替，插入排序或冒泡排序法用快速排序、合并排序或根排序代替，都可以大大 提高程序执行的效率。.选择一种合适的数据结构也很重要. 放的数中使用了大量的插入和...
如何优化单片机c语言代码
03-08
将比较慢的顺序查找法用较快的二分查找或乱序查找 [\U`si 法代替，插入排序或冒泡排序法用快速排序、合并排序或根排序代替，都可以大大 WNC["b[BFc 提高程序执行的效率。.选择一种合适的数据结构也很重要，比如你...
数据结构实验
04-13
实验1：顺序表基本操作 一、实验目的 1.学会定义线性表的顺序存储类型，实现C程序的基本结构，对线性表的一些基本操作和具体... 优化已完成的程序，使整个实验形成至少三级菜单管理； 2．美化输出界面，使得操作友好。
数据结构与算法.xmind
06-19
将两个已排好序的数组合并成一个有序的数组 做法 递归拆分出两个有序的数组，从mid的位置开始拆分，递归出口：只有一个值的时候就不用拆分了 合并两个有序的数据 分别往两个数组填充...
C语言实现顺序链表的合并（此方法不开辟新的空间，在原链表上操作，带头节点，两个原链表本身分别无重复元素）
zhan_qian的博客
09-23 505
#include<stdio.h> #include<stdlib.h> struct node{ int data; struct node *next; }; struct node *create(){ struct node *head; head=malloc(sizeof(struct node)); head->next=NULL; return head; } void Sq_insert(struct node.
合并两个排序的链表
scuzoutao的博客
08-22 176
方法1：*采用递归思想* public ListNode Merge(ListNode list1,ListNode list2) { if(list1 == null){ return list2; } if(list2 == null){ return list1; } if(list1.val &lt;= list2.val){ ...
C语言数据结构之顺序线性链表的合并
bool的博客
02-10 569
void MergeLinkList(LinkList * l1,LinkList * l2,LinkList * l3) { struct Node * na,*nb; na = l1-&gt;item; nb = l2-&gt;item; while(na &amp;&amp; nb) { if(na-&gt;value &gt;= n...
顺序表的合并
u010180915的专栏
10-06 4337
顺序表的合并的前提是合并的两个顺序表都要有序，你可以升序也可以降序，合并后的顺序表的是否为升序或降序就看内部代码的判断，当你输入完两个顺序表的时候，也可以调用冒泡法排序的函数，或者你先初始化两个有序的顺序表。本篇就直接输入有序的顺序表，具体的实现过程代码中有解释。 /* 顺序表的合并要满足两个顺序表都是有序的！！ */ #include #define N 50 int A[N]=
合并两个顺序的链表
GEPEIDUO的博客
08-02 1043
题目描述 输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。 方法一（递归） 合并过程中，首先比较两个链表的首节点哪个小，较小的节点作为合成链表的首节点，之后将指针指向较小节点的后一个节点，再次进行上面逻辑的比较，可以发现比较过程是一个递归的操作。 public static ListNode merge(ListNode list1, ListNode ...
合并两个排序的链表——链表、递归
yanner_的博客
08-02 171
题目描述 输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。 思路分析 用递归思想，依次将两个链表的每个元素递归对比后实现，注意此题考查代码的鲁棒性，故判断条件不能少！ /*function ListNode(x){ this.val = x; this.next = null; }*/ function Merge(pHead1,...
用算符优先法对算术表达式求值（六）
热门推荐
猪脚三父
11-23 1万+
18.11.23 这是一道最近刚上的实验课的题目。。。。 基于C语言，欢迎指正 实验要求 掌握栈在解决实际问题中的应用，设计一个程序，演算用算符优先法对算术表达式求值的过程，利用算符优先关系，实现对算术四则混合运算表达式的求值 。。挺难的。。 思路在这！ 思路 这个程序是这样，当你点击运行它的时候，你需要输一个表达式，然后按个回车，答案就出来了，跟个计算器一样 那么，在一开始，我们需要一个数组，来...
能够按照指数降序排列建立并输出多项式; 能够完成两个多项式的相加、相减，并将结果输入， 在上交资料中请写明:存储结构、多项式相加的基本过程的算法(可以使用程序流程图源程序、测试数据和结果、算法的时间复杂度、另外可以提出算法的改进方法C实现
最新发布
06-08
用户输入每一项的系数和指数，然后按照指数从大到小的顺序插入链表中。最后输出整个多项式即可。 3. 多项式的相加和相减： 两个多项式相加或相减的基本过程类似，只是加法和减法的细节不同。我们可以先将两个多项式...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值