LeetCode ：21.合并两个有序链表

1.题目

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

2.示例

输入：

1->2->4, 1->3->4

输出：

1->1->2->3->4->4

3.解法探析

3.1 解法 1：迭代法

3.1.1 解题思路

1.对于空链表，假如链表 l1为空则返回链表 l2，链表 l2为空则返回链表 l1。
2.比较链表 l1和链表 l2的第一个结点的值，将值小的结点保存下来作为合并后新链表的第一个结点，并把值小的结点的链表向后移动一位。
3.不断在两个链表剩下的结点中选择较小的值，链接到新链表的后面，直至某一个链表为空。
4.当两个链表长度不同时，会有一个链表先为空，此时把另外一个链表剩下的结点都连接到新链表的末尾。

3.1.2 代码实现

C++实现：

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (l1 == nullptr) {
            return l2;
        } else if (l2 == nullptr) {
            return l1;
        }

        // 申请dummy指针作为一个虚拟的头结点，并将其成员初始化为 -1
        ListNode* dummy = new ListNode(-1);                 
        ListNode* cur = dummy;

        while (l1 != nullptr && l2 != nullptr) {
            if (l1->val < l2->val) {
                cur->next = l1;
                l1 = l1->next;
            } else {
                cur->next = l2;
                l2 = l2->next;
            }

            cur = cur->next;
        }

        if (l1 == nullptr) {
            cur->next = l2;
        } else if (l2 == nullptr) {
            cur->next = l1;
        }

        return dummy->next;
    }
};

GO实现：

type ListNode struct {
    Val int
    Next *ListNode
}

func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
    // 如果有一个链表为 nil，直接返回另一个链表
    if l1 == nil {
        return l2
    } else if l2 == nil {
        return l1
    }

    // 定义一个临时的头指针，它的 Next 指向的结点才有数据
    dummy := &ListNode{}
    cur := dummy

    for l1 != nil && l2 != nil {
        if l1.Val < l2.Val {
            cur.Next = l1
            // cur 与 l1 都往后移动一位
            // 相当于 l1 = l1.Next cur = cur.Next
            cur, l1 = cur.Next, l1.Next
        } else {
            cur.Next = l2
            cur, l2 = cur.Next, l2.Next
        }
    }

    // 循环完之后，把链表剩下的结点直接放到后面，因为链表本身就是有序的，所以链接在后面就行
    if l1 == nil {
        cur.Next = l2
    } else if l2 == nil {
        cur.Next = l1
    }

    return dummy.Next
}

3.1.3 复杂度分析

时间复杂度：$O(n+m)$（假设 n 为链表1的长度，m 为链表2的长度）
空间复杂度：$O(1)$

3.2 解法 2：递归法

3.2.1 解题思路

1.对于空链表，假如链表 l1为空则返回链表 l2，链表 l2为空则返回链表 l1。
2.比较两个链表中第一个结点的大小，确定头结点的位置。
3.头结点确定后，继续在两个链表剩下的结点中选出较小的结点链接到第 2 步选出的结点后面，然后再继续重复 第 2、3 步，直到有链表为空。

3.2.2 代码实现

C++实现：

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(nullptr) {}
};

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        if (l1 == nullptr) {
            return l2;
        } else if (l2 == nullptr) {
            return l1;
        }

        if (l1->val < l2->val) {
            l1->next = mergeTwoLists(l1->next, l2);

            return l1;
        } else {
            l2->next = mergeTwoLists(l2->next, l1);

            return l2;
        }
    }
};

GO实现：

type ListNode struct {
    Val int
    Next *ListNode
}

func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
    // 如果有一个链表为 nil，直接返回另一个链表
    if l1 == nil {
        return l2
    } else if l2 == nil {
        return l1
    }

    // 对ListNode类型进行一次 new 的实例化操作，也可以使用 dummy := new(ListNode) 进行实例化
    dummy := &ListNode{}

    // 获取结构体实例的指针
    newHead := dummy

    if l1.Val < l2.Val {
        newHead = l1
        newHead.Next = mergeTwoLists(l1.Next, l2)
    } else {
        newHead = l2
        newHead.Next = mergeTwoLists(l2.Next, l1)
    }

    return newHead
}

3.2.3 复杂度分析

时间复杂度：$O(n+m)$（假设 n 为链表1的长度，m 为链表2的长度）
空间复杂度：$O(n+m)$

---

个人博客：

www.codeapes.cn