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

题目描述

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

示例1

• 输入：{1,3,5},{2,4,6}
• 返回值：{1,2,3,4,5,6}

---

题解：

题目要求：给两个非递减单链表l1, l2，合并为一个非递减的单链表。

方法一：迭代版本求解

将两个链表结点挨个进行比较，插入到一个新表中。

初始化：

定义cur指向新链表的头结点

操作：

1. 如果 pHead1 指向的结点值小于等于 pHead2 指向的结点值，则将 pHead1 指向的结点值链接到cur的next指针，然后 pHead1 指向下一个结点值
2. 否则，让 pHead2 指向下一个结点值
3. 循环步骤1,2，直到 pHead1 或者 pHead2 为nullptr
4. 将 pHead1 或者 pHead2 剩下的部分链接到cur的后面

技巧

一般创建单链表，都会设一个虚拟头结点，也叫哨兵，因为这样每一个结点都有一个前驱结点。

C#：

public class ListNode
    {
        public int val;
        public ListNode next;
        public ListNode (int x)
        {
            val = x;
        }
    }
    class Solution
    {
        public ListNode Merge(ListNode pHead1, ListNode pHead2)
        {
            if (pHead1 == null && pHead2 == null)
            {
                return null;
            }
            else if (pHead1 == null)
            {
                return pHead2;
            }
            else if (pHead2 == null)
            {
                return pHead1;
            }

            ListNode Head = new ListNode(0);
            ListNode cur = Head;

            while (pHead1 != null && pHead2 != null)
            {
                if (pHead1.val <= pHead2.val)
                {
                    cur.next = pHead1;
                    pHead1 = pHead1.next;
                }
                else
                {
                    cur.next = pHead2;
                    pHead2 = pHead2.next;
                }
                cur = cur.next;
            }

            if (pHead1 != null)
            {
                while (pHead1 != null)
                {
                    cur.next = pHead1;
                    pHead1 = pHead1.next;
                    cur = cur.next;
                }
            }
            else
            {
                while (pHead2 != null)
                {
                    cur.next = pHead2;
                    pHead2 = pHead2.next;
                    cur = cur.next;
                }
            }

            return Head.next;
        }
    }

• 时间复杂度：O(m+n),m，n分别为两个单链表的长度
• 空间复杂度：O(1)

方法二：递归版本

思路：

如果phead1小于phead2，则phead1作为新序列的开头，后面应该接的部分等同于phead1.next和phead2的重新排序。反之同理。

代码

    public class ListNode
    {
        public int val;
        public ListNode next;
        public ListNode (int x)
        {
            val = x;
        }
    }
    class Solution
    {
        public ListNode Merge(ListNode pHead1, ListNode pHead2)
        {
            if (pHead1 == null && pHead2 == null)
            {
            	return null;
            }
            else if (pHead1 == null)
            {
                return pHead2;
            }
            else if (pHead2 == null)
            {
                return pHead1;
            }
               
            if (pHead1.val <= pHead2.val)
            {
                pHead1.next = Merge(pHead1.next, pHead2);
                return pHead1;
            }
            else
            {
                pHead2.next = Merge(pHead1, pHead2.next);
                return pHead2;
            }
        }
    }

• 时间复杂度：O(m+n)
• 空间复杂度：O(m+n),每一次递归，递归栈都会保存一个变量，最差情况会保存(m+n)个变量。