一、题目简述
二、个人代码与思路
定位的,注意每一步之后,移动指针的更新。
class Solution
{
public:
ListNode* mergeTwoLists(ListNode* list1, ListNode* list2)
{
ListNode* p1=list1,*p2=list2;//以p2作为主链表进行插入
if(p2==nullptr)return list1;//主表为空,直接返回list1
while(p1!=nullptr&&p2!=nullptr)
{
if(p1->val>=p2->val)
{
if(p2->next&&p2->next->val>=p1->val)//利用短路,防止p2->next==nullptr
{//此时应该插入中间
list1=p1->next; //先保存
p1->next=p2->next;
p2->next=p1;
p1=list1; //移动
}
else if(p2->next==nullptr)
{
p2->next=p1;break;//直接串起来
}
else
{
p2=p2->next;
}
}
else if(p1->val<p2->val)
{//只有可能是头结点不太符合
list1=p1->next; //保存修改完后的头结点
p1->next=p2;
list2=p1;
p2=list2;//更新下一次需要比较的位置(移动)
p1=list1;
}
}
return list2;
}
};
三、参考题解与思路
1.迭代写法
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode* preHead = new ListNode(-1);
ListNode* prev = preHead;
while (l1 != nullptr && l2 != nullptr) {
if (l1->val < l2->val) {
prev->next = l1;
l1 = l1->next;
} else {
prev->next = l2;
l2 = l2->next;
}
prev = prev->next;
}
// 合并后 l1 和 l2 最多只有一个还未被合并完,我们直接将链表末尾指向未合并完的链表即可
prev->next = l1 == nullptr ? l2 : l1;
return preHead->next;
}
};
复杂度分析:
时间复杂度:O(n + m),其中 n 和 m 分别为两个链表的长度。因为每次循环迭代中,l1 和 l2 只有一个元素会被放进合并链表中, 因此 while 循环的次数不会超过两个链表的长度之和。所有其他操作的时间复杂度都是常数级别的,因此总的时间复杂度为 O(n+m)。
空间复杂度:O(1)。我们只需要常数的空间存放若干变量。
2.递归写法
(每一层都找出合适的结果节点)
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
if (l1 == nullptr) {
return l2;
} else if (l2 == nullptr) {
return l1;
} else if (l1->val < l2->val) {
l1->next = mergeTwoLists(l1->next, l2);
return l1;
} else {
l2->next = mergeTwoLists(l1, l2->next);
return l2;
}
}
};
复杂度分析
时间复杂度:O(n+m),其中 n 和 m 分别为两个链表的长度。因为每次调用递归都会去掉 l1 或者 l2 的头节点(直到至少有一个链表为空),函数 mergeTwoList 至多只会递归调用每个节点一次。因此,时间复杂度取决于合并后的链表长度,即 O(n+m)。
空间复杂度:O(n+m),其中 n和 m 分别为两个链表的长度。递归调用 mergeTwoLists 函数时需要消耗栈空间,栈空间的大小取决于递归调用的深度。结束递归调用时 mergeTwoLists 函数最多调用 n+mn+m 次,因此空间复杂度为 O(n+m)。