C语言：将两个非递减的有序链表合并为一个非递增的有序链表。结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间

最新推荐文章于 2024-08-15 19:50:02 发布
最新推荐文章于 2024-08-15 19:50:02 发布
阅读量9.9k 收藏 105
点赞数 26
文章标签： 数据结构 链表 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45286211/article/details/105376420
版权

将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中允许有重复的数据，并输出每一步从哪取下了什么元素


完整代码如下： 

#include<stdio.h>
#include<stdlib.h>
typedef struct link{		//定义链表
        int data;
        struct link *next;
}link;
link * initLink(int n){         //初始化链表，确定长度，输入数据
        link *p,*q;
        printf("依次输入数据:");
        for(int i=1;i<=n;i++){
                link *temp=(link*)malloc(sizeof(link));         //动态分配内存
                scanf("%d",&temp->data);        //填充数据
                temp->next=NULL;      //最后一个节点指针NULL
                if(i==1){
                        q=temp;         //给q,p赋值第一个结点
                        p=temp;
                }
                else{           //形成一条p链
                        p->next=temp;   //p陆续指向后边的结点
                        p=p->next;      //p移动到最后
                }
        }
        return q;
}
link * mergeList(link *a,link *b){      //合并两条传入的链表
        link *o,*p,*q;      //这里p中转，o指向最后一个元素，q指向最新元素
        int i=1;                //第一次合并使用
        while (a||b){
                if(!a){         //a空了，直接指向b的结点
                        printf("从b取下%d\n",b->data);
                        p=b;
                        b=b->next;
                }               //b空了或者a的数据<=b的数据时，指向a的结点
                else if(!b||a->data<=b->data){
                        printf("从a取下%d\n",a->data);
                        p=a;
                        a=a->next;
                }               //此处可和上面的合并
                else {
                        printf("从b取下%d\n",b->data);
                        p=b;
                        b=b->next;
                }
                if(i==1){

                        o=q=p;          //初始化指针
                        i++;            //使用一次舍弃
                }
                else {
                        p->next=q;        //使取下的结点连上合并后的链
                        q=p;              //更新q的位置到最新结点
                }
        }
        o->next=NULL;   //使最后一个指向NULL输出结束条件
        free(b);        //a，b，q的空间可以释放
        free(a);
        return q;
}
int main(){
        int m,n;                //记录a，b的长度
        printf("第一个链表的长度：");
        scanf("%d",&m);
        link *a = initLink(m);  //初始化a
        printf("第二个链表的长度：");
        scanf("%d",&n);
        link *b = initLink(n);  //初始化b
        link *c = mergeList(a,b);//合并a，b
        printf("合并链（非递增）：");
        while(c){
                printf("%d ",c->data);
                c=c->next;
        }
        return 0；
}

--------------------------------------------------分隔线------------------------------------------

由于最近数据结构课布置了这个作业，并且知识一知半解（练习少了），所以百度找了一些代码看，然后搞了七八个小时弄出来下面的代码

#include<stdio.h>
#include<stdlib.h>
typedef struct link{		//定义链表
        int data;
        struct link *next;
}link;
link * initLink(int n){         //初始化链表，确定长度，输入数据
        link *p,*q;
        printf("依次输入数据:");
        for(int i=1;i<=n;i++){
                link *temp=(link*)malloc(sizeof(link));         //动态分配内存
                scanf("%d",&temp->data);        //填充数据
                temp->next=NULL;      //最后一个节点指针NULL
                if(i==1){
                        q=temp;         //给q,p赋值第一个结点
                        p=temp;
                }
                else{           //形成一条p链
                        p->next=temp;   //p陆续指向后边的结点
                        p=p->next;      //p移动到最后
                }
        }
        return q;
}
link * mergeList(link *a,link *b){      //合并两条传入的链表
        link *p,*q;                     //p指向合并链表第一个元素
        q=(link*)malloc(sizeof(link));  //q：使合并链的最后一个元素为NULL
        q->next=NULL;
        int i=1;
        while (a||b){
                if(!a){         //a空了，直接指向b的结点
                        printf("从b取下%d\n",b->data);
                        p=b;
                        b=b->next;
                }               //b空了或者a的数据<=b的数据时，指向a的结点
                else if(!b||a->data<=b->data){
                        printf("从a取下%d\n",a->data);
                        p=a;
                        a=a->next;
                }
                else {
                        printf("从b取下%d\n",b->data);
                        p=b;
                        b=b->next;
                }
                p->next=q->next;        //使取下的结点连上合并后的链
                q->next=p;              //更新合并后的链
        }
        free(b);        //a，b，q的空间可以释放
        free(a);
        return p;
}
int main(){
        int m,n;                //记录a，b的长度
        printf("第一个链表的长度：");
        scanf("%d",&m);
        link *a = initLink(m);  //初始化a
        printf("第二个链表的长度：");
        scanf("%d",&n);
        link *b = initLink(n);  //初始化b
        link *c = mergeList(a,b);//合并a，b
        printf("合并链（非递增）：");
        while(c){
                printf("%d ",c->data);
                c=c->next;
        }
        return 0；
}

可是有一个地方我一直觉得有问题（由于基础不扎实），合并链表中我觉得好像不符合题意：不另外占用其它的存储空间。

在这里插入图片描述

这里给q分配空间我也不太知道违背题意没，但不太放心，于是我把mergeList函数做了一些修改（可以对比上面的代码）：

link * mergeList(link *a,link *b){      //合并两条传入的链表
        link *p,*q;                     //p指向合并链表第一个元素
        //q=(link*)malloc(sizeof(link));  //q：使合并链的最后一个元素为NULL
        //q->next=NULL;
        int i=1;                //第一次合并使用
        while (a||b){
                if(!a){         //a空了，直接指向b的结点
                        printf("从b取下%d\n",b->data);
                        p=b;
                        b=b->next;
                }               //b空了或者a的数据<=b的数据时，指向a的结点
                else if(!b||a->data<=b->data){
                        printf("从a取下%d\n",a->data);
                        p=a;
                        a=a->next;
                }               //此处可和上面的合并
/*              else if(a->data<=b->data){
                        printf("从a取下%d\n",a->data);
                        p=a;
                        a=a->next;
                }               //b的数据<a的数据时，指向b的结点（不可与！a合并
*/              else {
                        printf("从b取下%d\n",b->data);
                        p=b;
                        b=b->next;
                }
                if(i==1){
                        q=p;
                        q->next=p;
                        i++;            //使用一次舍弃
                }
                else {
                        p->next=q->next;        //使取下的结点连上合并后的链
                        q->next=p;              //更新合并后的链
                }
        }
        free(b);        //a，b，q的空间可以释放
        free(a);
        free(q);
        return p;
}

但是有问题，就是第一个元素的合并有一些问题，输出的是一些乱码
在这里插入图片描述
代码总体上不够完善，如果有大佬有好的建议或者可以解决后面这个问题欢迎指导。
(@ο@)
终于实现了不占用其他存储空间了，之前的代码确实不符合题意
所以更新代码为（只需要更换mergeList函数的代码）如下：

link * mergeList(link *a,link *b){      //合并两条传入的链表
        link *o,*p,*q;      //这里p中转，o指向最后一个元素，q指向最新元素
        int i=1;                //第一次合并使用
        while (a||b){
                if(!a){         //a空了，直接指向b的结点
                        printf("从b取下%d\n",b->data);
                        p=b;
                        b=b->next;
                }               //b空了或者a的数据<=b的数据时，指向a的结点
                else if(!b||a->data<=b->data){
                        printf("从a取下%d\n",a->data);
                        p=a;
                        a=a->next;
                }               //此处可和上面的合并
                else {
                        printf("从b取下%d\n",b->data);
                        p=b;
                        b=b->next;
                }
                if(i==1){

                        o=q=p;          //初始化指针
                        i++;            //使用一次舍弃
                }
                else {
                        p->next=q;        //使取下的结点连上合并后的链
                        q=p;              //更新q的位置到最新结点
                }
        }
        o->next=NULL;   //使最后一个指向NULL输出结束条件
        free(b);        //a，b，q的空间可以释放
        free(a);
        return q;
}

唉，一个题搞了可能有十多个小时，被指针的引用弄得晕头转向，逻辑思维不行，以后得训练训练。望各位学好数学(真心觉得数学不好太吃亏了），不然容易绕圈转，浪费太多时间。

君子使物，不为物使
关注
将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表仍使用原来两个链表的存储空间，不另外占用其他的存储空间。表中允许有重复的数据。
gezhishigechuan_的博客
04-18 7601
如有错误的地方还请斧正 emm.....涉及到的重要知识点： 引用： void Creat_LinkList(LinkList &L, int len);和void Decrease_LinkList(LinkList &L1, LinkList &L2)都涉及到一个点：“引用” 第一个函数的参数LinkList &L有必要说明一下，在链表操作中经常在函数参...
将两个递增的链表合并为一个非递减的链表
04-12
从键盘输入两个链表，通过程序对他们排序，之后按递增顺序合并链表
【考研数据结构算法刷题】将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表仍使用原来两个链表的存储空间，不另外占用其他的存储空间。表中允许有重复的数据。
最新发布
Code丶Q的博客
08-15 318
本代码针对考研数据结构，采用伪代码，主要理解代码思路，由于原链表是有重复数的升序序列，要求改降序，且不能占用其他存储空间，所以只能采用头插法进行。将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表仍使用原来两个链表的存储空间，不另外占用其他的存储空间。表中允许有重复的数据。
将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中允许有重复的数据。
集众人智慧，少走弯路，用对方法，事半功倍。祝考研成功，风里雨里，学长学姐，长理等你！
04-24 750
合并后的新表使用头指针Lc指向，pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，依次摘取其中较小者重新链接在Lc表的表头结点之后，如果两个表中的元素相等，只摘取La表中的元素，保留Lb表中的元素。当一个表到达表尾结点，为空时，将非空表的剩余元素依次摘取，链接在Lc表的表头结点之后。
将两个非递减的有序链表合并为一个非递增的有序链表，要求使用原来两个链表的存储空间，表中允许有重复的数据。
weixin_41423494的博客
10-19 1万+
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define MAXSIZE 20; typedef struct LNode{ int data; struct LNode *next; } LNode,*LinkList; LinkList mergelinklist(LinkList La,LinkList Lb); in...
将两个非递减的有序链表合并为一个非递增的有序链表
热门推荐
强强强子的博客
10-11 2万+
将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中允许有重复的数据。 void MergeList(LinkList& La, LinkList& Lb, LinkList& Lc, ) {//合并链表La和Lb，合并后的新表使用头指针Lc指向 pa=La->next; pb=Lb->next; //pa和p
将两个非递减的有序链表合并为一个非递增的有序链表。要求是结果仍使用原来两个链表的空间，不另外占用其他的存储空间。表中允许有重复的数据。
weixin_46803686的博客
11-12 963
#include<iostream> using namespace std; //第二题 typedef struct lnode { int data; struct lnode *next; } lnode,*LinkList; void CreateList(LinkList &L,int n) { lnode *p; L=new lnode; L->next=NULL; for(int i=0; i<n; i++)
数据结构2.2,将两个非递减的有序链表合并为一个非递增的有序链表，要求结果链表仍使用原来两个链表的存储空间，不占用其他的存储空间。表中允许有重复的数据。
2301_79783635的博客
09-15 2028
数据结构2.2,将两个非递减的有序链表合并为一个非递增的有序链表，要求结果链表仍使用原来两个链表的存储空间，不占用其他的存储空间。表中允许有重复的数据。
将两个非递减的有序链表合并为一个非递减的有序链表（利用原来两个链表的存储空间，表中不允许有重复数据）
福宝的各种玩意~
10-17 3389
将两个非递减的有序链表合并为一个非递减的有序链表。 （要求利用原来两个链表的存储空间，不另外占用其他空间，表中不允许有重复数据）
2个按值非递减的链表合并（数据结构）
02-14
数据结构中的链表合并： //合并函数 void MergeList_L(LinkList &L1;,LinkList &L2;,LinkList &L3;) { //已知单链线性表L1和L2的元素按值非递减排列。 //归并L1和L2得到新的单链线性表L3，L3的元素也按值非递减排列。 ...... }
C++版本将两个有序链表合并为一个新的有序链表并返回原理及代码实现
07-03
### C++ 版本将两个有序链表合并为一个新的有序链表并返回原理及代码实现 在计算机科学中，链表是一种常见的数据结构，广泛应用于各种算法和数据处理任务中。本文将详细介绍如何使用C++语言来实现一个功能，即合并...
探讨:将两个链表非降序合并为一个链表并依然有序的实现方法
09-05
在本文中，我们将深入探讨如何将两个非降序排列的链表合并成一个新的有序链表。这个过程涉及到链表操作，包括遍历、比较和插入元素。首先，我们需要理解链表的基本结构，它是由一系列节点组成，每个节点包含数据部分...
链表：将两个非递减的有序链表合并为一个非递增的有序链表.要求结果链表仍使用原来两个链表的存储空间，不另外占用其他的存储空间。表中允许有重复的数据。
qq_45089234的博客
03-09 3230
将两个非递减的有序链表合并为一个非递增的有序链表.要求结果链表仍使用原来两个链表的存储空间，不另外占用其他的存储空间。表中允许有重复的数据。 void MergeList(LinkList& La, LinkList& Lb, LinkList& Lc, ) { //合并链表La和Lb，合并后的新表使用头指针Lc指向 pa=L...
2.（1）将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来的两个链表的存储空间，不另外占用其他的存储空间。表中不允许有重复的数据
qq_53938756的博客
05-20 3856
因为要将两个有序单链表合并为一个递增的有序单链表，所以我们建立了三个单链表La，Lb，Lc，但是要求结果链表仍然使用原来两个链表的存储空间，所以我们用La的头结点作为Lc的头结点，这样直接操作单链表后，输出La单链表和Lc单链表结果是一样的。然后我们算法实现的思路是用三个工作结点pa，pb，pc指向此结点，然后进行比较，pa指向的此结点依次与pb的结点比较，直到比此时pb结点小，然后pa向下一个结点进行移动，然后重复刚刚的比较，直到其中一个单链表已经到尾结点。
C语言数据结构算法之——将两个非递减的有序链表合并为一个非递增的有序链表。结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间（算法2）
dalianlianzuida的博客
06-10 1144
代码（算法2）： /*C语言：将两个非递减的有序链表合并为一个非递增的有序链表。 结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间*/ /*算法2*/ #include<stdio.h> #include<malloc.h> typedef struct list { int data; struct list * next; //下一个节点地址 }list,*Linklist; //第一条链表 Linklist L=NUL
将两个非递增的有序链表合并为一个非递减的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中允许有重复的数据
Blog
12-25 3114
将两个非递增的有序链表合并为一个非递减的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中允许有重复的数据操作的名称和参数使用下列结构：La和Lb表示将要合并的链表，合并后的新表使用头指针Lc指向。 void MergeList(LinkList& La, LinkList& Lb, LinkList& Lc) 网上查到的大部分是两个非递减（即递增）的有序链表，书上的也是非递减链表合并成非递减（递增）链表，而题目要求的是非递增（即递减）的有序链表
将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来两个链表的存储空间，不另外占用其他的存储空间。表中不允许有重复的数据。
qq_43794560的博客
10-11 244
因为LA是创造出来的链表，要是还释放掉，那创造出来干神么内。原因是用了多个getchar(),建议改成system(“pause”);scanf里面不用填“\n”，填了反而导致你必须输入一个数字敲一次回车。把delete、free都删了可以减少一大半的崩溃。
C语言将两个非递减的有序链表合并为一个非递增的有序链表，仍然用原来的存储空间
05-05
假设两个非递减有序链表分别为A和B，可以按照以下步骤合并它们： 1. 定义三个指针，分别指向A的当前节点、B的当前节点和A的前一个节点，初始时A和B的当前节点都指向链表头，A的前一个节点为NULL。 2. 从A和B中选择较小的节点，将其接到A的前一个节点后面。 3. 将A的前一个节点指向新加入的节点。 4. 将A的当前节点指向下一个节点，B的当前节点指向下一个节点。 5. 重复步骤2-4，直到A和B中任意一个链表为空。 6. 如果A链表已经为空，则将B链表剩余的节点全部接到A链表的前面。 7. 将A链表反转，得到一个非递增有序链表。 下面是具体的C语言实现代码： ```c #include <stdio.h> #include <stdlib.h> // 定义链表节点结构体 typedef struct Node { int val; struct Node* next; } Node; // 将链表反转 Node* reverse(Node* head) { Node *p, *q, *r; p = head; q = NULL; while (p != NULL) { r = p->next; p->next = q; q = p; p = r; } return q; } // 将两个非递减有序链表合并为一个非递增有序链表 void merge(Node* A, Node* B) { Node *pa, *pb, *prev; pa = A->next; pb = B->next; prev = A; while (pa != NULL && pb != NULL) { if (pa->val <= pb->val) { prev->next = pa; prev = pa; pa = pa->next; } else { prev->next = pb; prev = pb; pb = pb->next; } } if (pb != NULL) { prev->next = pb; } A->next = reverse(A->next); } int main() { // 构造两个非递减有序链表 Node* A = (Node*)malloc(sizeof(Node)); A->next = NULL; Node* B = (Node*)malloc(sizeof(Node)); B->next = NULL; Node* p = A; Node* q = B; int a[] = {1, 3, 5, 7, 9}; int b[] = {2, 4, 6, 8, 10}; int i; for (i = 0; i < 5; i++) { p->next = (Node*)malloc(sizeof(Node)); p = p->next; p->val = a[i]; p->next = NULL; q->next = (Node*)malloc(sizeof(Node)); q = q->next; q->val = b[i]; q->next = NULL; } // 合并两个链表并输出结果 merge(A, B); Node* r = A->next; while (r != NULL) { printf("%d ", r->val); r = r->next; } printf("\n"); return 0; } ``` 上述代码中，我们首先定义了一个链表节点结构体，然后按照题目要求，构造了两个非递减有序链表A和B，接着调用merge函数将它们合并为一个非递增有序链表，并最终输出合并后的结果。在merge函数中，我们分别用pa和pb指向A和B的当前节点，prev指向A的前一个节点。从A和B中选择较小的节点，将其接到A的前一个节点后面，然后将A的前一个节点指向新加入的节点，将A的当前节点指向下一个节点，B的当前节点指向下一个节点。重复这个过程，直到A和B中任意一个链表为空。如果A链表已经为空，则将B链表剩余的节点全部接到A链表的前面。最后调用reverse函数将A链表反转，得到一个非递增有序链表。
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值