两个链表的合并

已于 2023-04-06 01:32:11 修改
阅读量350 收藏
点赞数
分类专栏： 日常学习 文章标签： 链表 数据结构 算法
于 2023-04-06 01:11:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73063535/article/details/129980649
版权 
#include <stdio.h>
#include <stdlib.h>

typedef struct student {
    int num;   // 学号
    int score;   // 成绩
    struct student* next;
} Student;

// 创建新结点
Student* createNode(int num, int score) {
    Student* node = (Student*)malloc(sizeof(Student));
    node->num = num;
    node->score = score;
    node->next = NULL;
    return node;
}

// 合并并按学号升序排序两个链表
Student* mergeLinkedList( Student* a, Student* b ) {
    Student *p = a, *q = b, *prev = NULL, *head = NULL;

    while( p != NULL && q != NULL ) {
        if( p->num <= q->num ) {
            if( prev == NULL ) head = p;
            else prev->next = p;

            prev = p;
            p = p->next;
        }
        else {
            if( prev == NULL ) head = q;
            else prev->next = q;

            prev = q;
            q = q->next;
        }
    }

    if( p == NULL ) prev->next = q;
    else prev->next = p;

    return head;
}

// 输出链表中的所有结点
void printLinkedList(Student* L) {
    printf("num\t score\n");
    while (L != NULL) {
        printf("%d\t %d\n", L->num, L->score);
        L = L->next;
    }
}

int main() {
    Student *headA = NULL, *headB = NULL, *headC = NULL;   // 三个单向链表

    // 分别读入两个链表 a 和 b
    int n, i, x, y;
    printf("Input the number of students in list a: ");
    scanf("%d", &n);
    for (i = 0; i < n; ++i) {
        printf("Input the num and score of the %dth student: ", i + 1);
        scanf("%d%d", &x, &y);
        Student* node = createNode(x, y);
        node->next = headA;
        headA = node;
    }

    printf("Input the number of students in list b: ");
    scanf("%d", &n);
    for (i = 0; i < n; ++i) {
        printf("Input the num and score of the %dth student: ", i + 1);
        scanf("%d%d", &x, &y);
        Student* node = createNode(x, y);
        node->next = headB;
        headB = node;
    }

    // 将两个链表合并
    headC = mergeLinkedList(headA, headB);

    // 输出新链表
    printf("The merged list:\n");
    printLinkedList(headC);

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

typedef struct student {
    int num;   // 学号
    int score;   // 成绩
    struct student* next;
} Student;

typedef struct {
    Student* head;
} LinkedList;

// 初始化单向链表
void initLinkedList(LinkedList* L) {
    L->head = NULL;
}

// 创建新结点
Student* createNode(int num, int score) {
    Student* node = (Student*)malloc(sizeof(Student));
    node->num = num;
    node->score = score;
    node->next = NULL;
    return node;
}

// 按学号升序插入结点
void insertNode(LinkedList* L, Student* node) {
    if (L->head == NULL || node->num < L->head->num) {
        node->next = L->head;
        L->head = node;
    } else {
        Student* p = L->head;
        while (p->next != NULL && p->next->num <= node->num) {
            p = p->next;
        }
        node->next = p->next;
        p->next = node;
    }
}

// 输出链表中的所有结点
void printLinkedList(LinkedList* L) {
    Student* p = L->head;
    printf("num\t score\n");
    while (p != NULL) {
        printf("%d\t %d\n", p->num, p->score);
        p = p->next;
    }
}

int main() {
    LinkedList a, b, c;   // 三个单向链表
    initLinkedList(&a);
    initLinkedList(&b);
    initLinkedList(&c);

    // 分别读入两个链表 a 和 b
    int n, i, x, y;
    printf("Input the number of students in list a: ");
    scanf("%d", &n);
    for (i = 0; i < n; ++i) {
        printf("Input the num and score of the %dth student: ", i + 1);
        scanf("%d%d", &x, &y);
        Student* node = createNode(x, y);
        insertNode(&a, node);
    }

    printf("Input the number of students in list b: ");
    scanf("%d", &n);
    for (i = 0; i < n; ++i) {
        printf("Input the num and score of the %dth student: ", i + 1);
        scanf("%d%d", &x, &y);
        Student* node = createNode(x, y);
        insertNode(&b, node);
    }

    // 将两个链表合并
    Student *pa = a.head, *pb = b.head;
    while (pa != NULL && pb != NULL) {
        if (pa->num <= pb->num) {
            Student* node = createNode(pa->num, pa->score);
            insertNode(&c, node);
            pa = pa->next;
        } else {
            Student* node = createNode(pb->num, pb->score);
            insertNode(&c, node);
            pb = pb->next;
        }
    }
    while (pa != NULL) {
        Student* node = createNode(pa->num, pa->score);
        insertNode(&c, node);
        pa = pa->next;
    }
    while (pb != NULL) {
        Student* node = createNode(pb->num, pb->score);
        insertNode(&c, node);
        pb = pb->next;
    }

    // 输出新链表
    printf("The merged list:\n");
    printLinkedList(&c);

    return 0;
}

这个使用了结构体，时间会超限

#include <stdio.h>

typedef struct {
    int num;   // 学号
    int score;   // 成绩
} Student;

// 归并排序算法
void mergeSort(Student* a, int lo, int hi) {
    if (lo >= hi) return;
    int mid = (lo + hi) / 2;
    mergeSort(a, lo, mid);
    mergeSort(a, mid + 1, hi);

    int i = lo, j = mid + 1, k = 0;
    Student temp[hi - lo + 1];
    while (i <= mid && j <= hi) {
        if (a[i].num <= a[j].num) {
            temp[k++] = a[i++];
        } else {
            temp[k++] = a[j++];
        }
    }
    while (i <= mid) {
        temp[k++] = a[i++];
    }
    while (j <= hi) {
        temp[k++] = a[j++];
    }
    for (i = 0; i < k; ++i) {
        a[lo + i] = temp[i];
    }
}

int main() {
    int n, m, i, j, k;
    Student a[100], b[100], c[200];

    // 分别读入两个数组 a 和 b
    printf("Input the number of students in list a: ");
    scanf("%d", &n);
    for (i = 0; i < n; ++i) {
        printf("Input the num and score of the %dth student: ", i + 1);
        scanf("%d%d", &a[i].num, &a[i].score);
    }

    printf("Input the number of students in list b: ");
    scanf("%d", &m);
    for (i = 0; i < m; ++i) {
        printf("Input the num and score of the %dth student: ", i + 1);
        scanf("%d%d", &b[i].num, &b[i].score);
    }

    // 按照学号升序合并数组 a 和 b 到 c 中
    i = j = k = 0;
    while (i < n && j < m) {
        if (a[i].num <= b[j].num) {
            c[k++] = a[i++];
        } else {
            c[k++] = b[j++];
        }
    }
    while (i < n) {
        c[k++] = a[i++];
    }
    while (j < m) {
        c[k++] = b[j++];
    }

    // 对新数组 c 按照学号升序排序
    mergeSort(c, 0, k - 1);

    // 输出新数组
    printf("The merged and sorted list:\n");
    for (i = 0; i < k; ++i) {
        printf("%d %d\n", c[i].num, c[i].score);
    }

    return 0;
}

改进算法

#include <stdio.h>

typedef struct {
    int num;   // 学号
    int score;   // 成绩
} Student;

// 归并排序算法
void mergeSort(Student* a, int lo, int hi) {
    if (lo >= hi) return;
    int mid = (lo + hi) / 2;
    mergeSort(a, lo, mid);
    mergeSort(a, mid + 1, hi);

    int i = lo, j = mid + 1, k = 0;
    Student temp[hi - lo + 1];
    while (i <= mid && j <= hi) {
        if (a[i].num <= a[j].num) {
            temp[k++] = a[i++];
        } else {
            temp[k++] = a[j++];
        }
    }
    while (i <= mid) {
        temp[k++] = a[i++];
    }
    while (j <= hi) {
        temp[k++] = a[j++];
    }
    for (i = 0; i < k; ++i) {
        a[lo + i] = temp[i];
    }
}

int main() {
    int n, m, i, j, k;
    Student a[100], b[100], c[200];

    // 分别读入两个数组 a 和 b
    scanf("%d", &n);
    for (i = 0; i < n; ++i) {
        scanf("%d %d", &a[i].num, &a[i].score);
    }

    scanf("%d", &m);
    for (i = 0; i < m; ++i) {
        scanf("%d%d", &b[i].num, &b[i].score);
    }

    // 按照学号升序合并数组 a 和 b 到 c 中
    i = j = k = 0;
    while (i < n && j < m) {
        if (a[i].num <= b[j].num) {
            c[k++] = a[i++];
        } else {
            c[k++] = b[j++];
        }
    }
    while (i < n) {
        c[k++] = a[i++];
    }
    while (j < m) {
        c[k++] = b[j++];
    }

    // 对新数组 c 按照学号升序排序
    mergeSort(c, 0, k - 1);

    // 输出新数组
    for (i = 0; i < k; ++i) {
        printf("%d %d\n", c[i].num, c[i].score);
    }

    return 0;
}

此代码产生了，数组越界问题

#include <stdio.h>

typedef struct {
    int num;   // 学号
    int score;   // 成绩
} Student;

// 归并排序算法
void mergeSort(Student* a, int lo, int hi) {
    if (lo >= hi) return;
    int mid = (lo + hi) / 2;
    mergeSort(a, lo, mid);
    mergeSort(a, mid + 1, hi);

    int i = lo, j = mid + 1, k = 0;
    Student temp[hi - lo + 1];
    while (i <= mid && j <= hi) {
        if (a[i].num <= a[j].num) {
            temp[k++] = a[i++];
        } else {
            temp[k++] = a[j++];
        }
    }
    while (i <= mid) {
        temp[k++] = a[i++];
    }
    while (j <= hi) {
        temp[k++] = a[j++];
    }
    for (i = 0; i < k; ++i) {
        a[lo + i] = temp[i];
    }
}

int main() {
    int n, m, i, j, k;
    Student a[110], b[110], c[220];   // 扩大数组定义范围

    // 分别读入两个数组 a 和 b
    scanf("%d", &n);
    for (i = 0; i < n && i < 100; ++i) {   // 判断输入的大小是否超出了数组定义范围
        scanf("%d %d", &a[i].num, &a[i].score);
    }

    scanf("%d", &m);
    for (i = 0; i < m && i < 100 ; ++i) {   // 判断输入的大小是否超出了数组定义范围
        scanf("%d%d", &b[i].num, &b[i].score);
    }

    // 按照学号升序合并数组 a 和 b 到 c 中
    i = j = k = 0;
    while (i < n && j < m) {
        if (a[i].num <= b[j].num) {
            c[k++] = a[i++];
        } else {
            c[k++] = b[j++];
        }
    }
    while (i < n) {
        c[k++] = a[i++];
    }
    while (j < m) {
        c[k++] = b[j++];
    }

    // 对新数组 c 按照学号升序排序
    mergeSort(c, 0, k - 1);

    // 输出新数组
    for (i = 0; i < k && i < 200; ++i) {   // 判断输出的大小是否超出了数组定义范围
        printf("%d %d\n", c[i].num, c[i].score);
    }

    return 0;
}

修改后的代码

#include <stdio.h>
#include <stdlib.h>   // 用到 malloc 和 free 函数

typedef struct Linklist1052{
    int num;
    int score;
    struct Linklist1052 *next;
}Node;

Node* create(int n){
    Node *p1,*p2;
    Node *head = NULL;
    p1=p2=(Node *)malloc(sizeof(Node));

    for(int i=0;i<n;i++){
        scanf("%d %d",&p1->num,&p1->score);
        if(i==0){
            head=p1;
        }else{
            p2->next=p1;
        }
        p2=p1;
        p1=(Node *)malloc(sizeof(Node));
    }
    p2->next=NULL;
    return head;
}

void print1052(Node *head){
    Node *p = head;
    if(head!=NULL){
        while(p!=NULL){
            printf("%d %d\n",p->num,p->score);
            p=p->next;
        }
    }
}

// 对链表进行归并和排序操作
Node *pai1052(Node *a, Node *b, int n, int m){
    Node *p,*q,*head,*min,*minq,*newp;
    head=NULL;
    p=a;
    while(p->next!=NULL){
        p=p->next;
    }
    p->next=b;
    q=min=q=p;

    for(int i=0; i<n+m; i++){
        p=a;
        q=minq=min=p;
        // 寻找num最小指针
        while(p!=NULL){
            if(min->num>p->num){
                min=p;
                minq=q;
            }
            q=p;
            p=p->next;
        }
        if(min==a){  // 首位最小的情况
            a=a->next;
        } 
        // 解绑
        minq->next=min->next; 
        if(i==0){
            head=min;
        }else{
            newp->next=min;
        }
        newp=min;
    }
    newp->next=NULL;
    return head;
}

int main(){
    Node *a,*b,*ab;
    int n,m;
    scanf("%d",&n);
    scanf("%d",&m);
    a=create(n);
    b=create(m);
    ab=pai1052(a,b,n,m);
    print1052(ab);

    // 释放内存，防止内存泄漏
    Node *temp = NULL;
    while (a != NULL)
    {
        temp = a;
        a = a->next;
        free(temp);
    }
    while (b != NULL)
    {
        temp = b;
        b = b->next;
        free(temp);
    }
    while (ab != NULL)
    {
        temp = ab;
        ab = ab->next;
        free(temp);
    }

    return 0;
}

最后解决代码

苏生十一_Nojambot
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
两个链表合并为一个链表
相识在雨中的博客
12-09 2009
两个链表合并为一个链表
将两个链表合并为一个链表
weixin_45613730的博客
04-26 3493
#include <stdio.h> #include <malloc.h> #include <stdlib.h> typedef struct LNode{ int data; struct LNode * next; }LNode ,* LinkList ; void CreatList(LinkList * L,int n); void ListTraverse(LinkList ); bool GetElem(LinkList L,int *i,int *e);
用python实现两个链表合并
weixin_42592399的博客
02-12 357
用python实现两个链表合并的方法是：首先，检查两个链表的头节点，找出具有较小值的头节点，将该头节点设置为新链表的头节点；然后，从两个链表中各取出一个节点，比较它们的值，将较小的节点加入到新链表中；重复上述步骤，直到两个链表中的所有节点都添加到新链表中，即可实现两个链表的合并。 ...
两个链表合并一个链表
dreanms的博客
05-19 802
如果当前节点的值大于等于另一个节点的值，则将当前节点的下一个节点设为另一个节点，并将 ans 的指针向后移动，直到其中一个链表遍历完毕。如果当前节点的值小于另一个节点的值，则将当前节点的下一个节点设为当前节点，并将 ans 的指针向后移动，直到其中一个链表遍历完毕。最后，当其中一个链表遍历完毕时，需要将 ansp 的指针指向其最后一个节点，表示新链表中不包含两个链表的尾节点，只包含剩余节点。接着，创建一个新链表 ans，并将 ans 的头节点设为 -1，表示新链表中不包含头节点。
将两个有序链表合并
weixin_47988506的博客
08-14 7595
无
给定两个链表，每个链表都已经按升序排列，设计算法实现将两个链表合并到一个升序链表中，返回合并后的链表
weixin_56735772的博客
05-01 1587
给定两个链表，每个链表都已经按升序排列，设计算法实现将两个链表合并到一个升序链表中，返回合并后的链表
合并两个有序链表
a1085653724的博客
05-07 7024
1.将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1： 输入：l1 = [1,2,4], l2 = [1,3,4] 输出：[1,1,2,3,4,4] 示例 2： 输入：l1 = [], l2 = [] 输出：[] 示例 3： 输入：l1 = [], l2 = [0] 输出：[0] 解题思路：1.用尾插的方法来合并链表，没有新建节点，是拼接节点。 2.先是判断特殊情况，若l1和l2中其中一个为空，直接链接对方链表：例如l1为空，则链接l
将两个链表合并成有序链表(归并法)
anyway33的博客
05-03 1242
链接:https://leetcode-cn.com/problems/merge-two-sorted-lists/ //1.哨兵位+双指针法(有错误，待修改) struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) { struct ListNode* head=(struct ListNode*)malloc(sizeof(struct ListNode*)); if(h.
链表合并：一个升序，一个降序，将两个链表合并成一个升序链表
小马快跑的博客
04-14 2552
题目：两个有序链表，一个升序，一个降序，如何将两个链表合并成一个升序链表。如: 升序链表一：1->2->3->4 降序链表二：6->5->4->3 合并后结果：1->2->3->3->4->4->5->6 思考：分成两步来实现，首先将降序链表二进行反转变成升序链表，然后就可以直接对两个升序链表进行操作了。 实现： public static void main(String[] args) { System.out.p
C语言——合并两个有序链表
2301_80185370的博客
04-26 1718
那么可以malloc一个新的节点fhead作为哨兵节点，将tail(尾节点）置为fhead，而真正的头则是fhead->next。如果list2节点较小，取list2头节点，进行尾插，list1节点不动，等待下一次比较。图中取list2节点，list向后走，list1不动，tail更新。如上图所示：当list1走完后，list2中剩余较大的数据，此时直接将list2链接到fhead的尾部即可。第一次比较list1节点的val较小，取下进行头插，list1向后走，list2不动。与数组类似，比较每一个节点。
c++ 如何合并两个有序链表
08-18
已知两个链表 head1 和 head2 各自有序，请把它们合并成一个链表，依然有序。结果链表要包含 head1 和 head2 的所有节点，即使节点值相同。注意：不能开辟新空间来存储合并后的链表。 二、非递归实现 非递归实现...
21. 合并两个有序链表
01-20
新链表是通过拼接给定的两个链表的所有节点组成的。 示例： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 解题思路 解法一：迭代法 复杂度分析： 时间复杂度：O(n + m) ，其中 n 和 m 分别为两个链表的长度。...
实现两个链表的合并
07-06
（1）建立两个链表A和B 链表元素个数分别为m和n个 （2）假设元素分别为 x1 x2 …xm 和 y1 y2 …yn 把它们合并成一个线性表C 使得： 当m> n时 C x1 y1 x2 y2 …xn yn … xm 当n>m时 C y1 x1 y2 x2 …ym xm ...
探讨:将两个链表非降序合并为一个链表并依然有序的实现方法
09-05
在本文中，我们将深入探讨如何将两个非降序排列的链表合并成一个新的有序链表。这个过程涉及到链表操作，包括遍历、比较和插入元素。首先，我们需要理解链表的基本结构，它是由一系列节点组成，每个节点包含数据部分...
Python实现合并两个有序链表的方法示例
09-19
在合并两个链表时，我们需要考虑以下几点： 1. **处理特殊情况**：如果其中一个链表为空，那么返回另一个非空链表即可。 2. **选择起点**：比较两个链表的第一个节点，选取值较小的作为合并后链表的起始节点。 3. *...
数据结构(5.4_1)——树的存储结构
最新发布
m0_65240792的博客
08-02 287
每个结点中保存指向双亲的“指针” 新增数据元素无需按逻辑上的次序存储，之家在上一个结点后添加新结点，并记录双亲结点 1、删除结点数据域 2、将尾部数据移动至删除结点位置填充空缺寻找其双亲结点相同的结点顺序存储各个节点，每个结点中保存孩子的链表头指针 树和二叉树的转化： 使用孩子兄弟表示法
数据结构(面试)
Anterior_condyle的博客
08-01 1249
在含有n个带权叶节点的二叉树中，其中带权路径（WPL）最小的二叉树称为哈夫曼树，也称最优二叉树。
2024.7.24 作业
qq_64434282的博客
07-24 3210
【代码】2024.7.24 作业。
浅谈用二分和三分法解决问题（c++）
2301_79587247的博客
07-29 955
头牛不满于隔间的位置分布，它们为牛棚里其他的牛的存在而愤怒。为了防止牛之间的互相打斗，Farmer John 想把这些牛安置在指定的隔间，所有牛中相邻两头的最近距离越大越好。而如果某个问题的解空间是单峰的，不管是向外凸还是向内凹，都可以用另一种算法解决，三分。的数列，我们需要找出该数列的一个子串，使得子串平均数最大化，并且子串长度。顾名思义，三分就是一种把解空间分成三段的算法，答案一定在某个段内，时间是。门考试成绩，您的累积平均成绩的可能最大值是多少。的数量应该尽可能的多，并且当她的 IQ 为。
两个链表合并使用链表头插法
09-12
要链表头插法将两个链表合并，可以按照以下步骤进行操作： 1. 首先，定义一个新的链表LC，用于存储合并后的结果。同时，创建指针pa和pb分别指向链表LA和LB的头节点。 2. 将LC指向LA，同时创建指针pc也指向LC的头节点...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

苏生十一_Nojambot

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值