剑指 Offer 25. 合并两个排序的链表

最新推荐文章于 2025-12-07 21:20:15 发布

原创最新推荐文章于 2025-12-07 21:20:15 发布 · 147 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#链表 #算法 #数据结构

算法竞赛专栏收录该内容

148 篇文章

订阅专栏

本文介绍了一种算法，用于合并两个递增排序的链表，并保持新链表的递增排序。提供了三种解决方案：使用辅助链表、直接插入和递归方法。详细展示了每种方法的代码实现。

输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

示例1：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

限制：

0 <= 链表长度 <= 1000

解题思路

总计有三种方式求解：

创建一个辅助链表，从两个链表中对比插入，若一个链表遍历结束，那么另一个链表剩下部分直接用尾插法插入即可，因为链表是有序的。
直接将一个链表中的数据插入另一个链表
利用递归求解

辅助链表代码展示

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (l1==NULL || l2==NULL)return l1?l1:l2;

        ListNode* HeadList = NULL;
        ListNode* PreList = NULL;
        while (l1 && l2)
        {
            if (l1->val>l2->val)
            {
                if(!HeadList)HeadList=new ListNode(l2->val);
                else
                {
                    ListNode* List = new ListNode(l2->val);
                    PreList->next=List;
                    PreList=PreList->next;
                }
                l2=l2->next;
            }
            else
            {
                if(!HeadList)HeadList=new ListNode(l1->val);
                else
                {
                    ListNode* List = new ListNode(l1->val);
                    PreList->next=List;
                    PreList=PreList->next;
                }
                l1=l1->next;
            }

            if(!PreList)PreList=HeadList;
        }

        if (l1)PreList->next=l1;
        if (l2)PreList->next=l2;


        return HeadList;
    }
};

插入链表代码展示

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (l1==NULL || l2==NULL)return l1?l1:l2;

        if(l2->val<l1->val)return mergeTwoLists(l2,l1);//确保l1的初值最小

        ListNode* T = l1;ListNode* pre = NULL;
        while(T && l2)
        {
            while(T && l2->val>=T->val)
            {
                pre = T;
                T=T->next;
            }
            pre->next = l2;
            if(T)
            {
                l2=l2->next;
                pre->next->next=T;
                pre = pre->next;
            }
        }
        return l1;
    }
};

递归代码展示

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (l1==NULL || l2==NULL)return l1?l1:l2;

        ListNode* pre = NULL;
        if(l1->val<l2->val)
        {
            pre = l1;   
            pre->next = mergeTwoLists(l1->next,l2);
        }
        else
        {
            pre = l2;   
            pre->next = mergeTwoLists(l1,l2->next);
        }
        return pre;
    }
};