LeetCode ：21.合并两个有序链表
题目
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例
输入：
1->2->4, 1->3->4
输出：
1->1->2->3->4->4
解法探析
解法 1：迭代法
解题思路
1.对于空链表，假如
链表 l1为空则返回链表 l2，链表 l2为空则返回链表 l1。
2.比较链表 l1和链表 l2的第一个结点的值，将值小的结点保存下来作为合并后新链表的第一个结点，并把值小的结点的链表向后移动一位。
3.不断在两个链表剩下的结点中选择较小的值，链接到新链表的后面，直至某一个链表为空。
4.当两个链表长度不同时，会有一个链表先为空，此时把另外一个链表剩下的结点都连接到新链表的末尾。
代码实现
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
}
复杂度分析
时间复杂度：\(O(n + m)\)（假设 n 为链表1的长度，m 为链表2的长度）
空间复杂度：\(O(1)\)
解法 2：递归法
解题思路
1.对于空链表，假如
链表 l1为空则返回链表 l2，链表 l2为空则返回链表 l1。
2.比较两个链表中第一个结点的大小，确定头结点的位置。
3.头结点确定后，继续在两个链表剩下的结点中选出较小的结点链接到第 2 步选出的结点后面，然后再继续重复 第 2、3 步，直到有链表为空。
代码实现
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
}
复杂度分析
时间复杂度：\(O(n + m)\)（假设 n 为链表1的长度，m 为链表2的长度）
空间复杂度：\(O(n + m)\)
个人主页：
