解决链表问题, 经常会用一个空的节点进行辅助.
可以先考虑递归, 新建一个节点, 然后选择两个链表里面小的, 链到新建的节点. 之后移动被选择的链表, 递归这个问题.
ListNode *Merge(ListNode *pHead1, ListNode *pHead2) {
if (pHead1 == nullptr) {
return pHead2;
}
if (pHead2 == nullptr) {
return pHead1;
}
ListNode *merge;
if (pHead1->val < pHead2->val) {
merge = pHead1;
merge->next = Merge(pHead1->next, pHead2);
} else {
merge = pHead2;
merge->next = Merge(pHead1, pHead2->next);
}
return merge;
}
说实话, 这个方案在力库上跑了下, 整体表现还可以. 不比非递归差多少.
那么非递归的思路也是一样, 新建一个节点, 每次对比两个链的值, 选择小的链上. 最后把剩余没跑完的, 一次性链接即可.
auto before = new ListNode(0);
auto cur = before;
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;
}
cur->next = l1 != nullptr ? l1 : l2;
return before->next;
这里用到了一个哨兵节点, 等于保留了前一个节点的位置, 让问题简化很多.
但是上面的问题, 这个点还不明显, 反转链表就很需要这样一个哨兵节点了.
ListNode *ReverseList(ListNode *head) {
if (head == nullptr) {
return nullptr;
}
ListNode *ret = nullptr;
auto move = head;
while (move) {
auto next = move->next;
move->next = ret;
ret = move;
move = next;
}
return ret;
}
先保存当前点的next位置, 让next指到哨兵节点, 然后把当前位置赋值到哨兵节点, 等于是手动让其前进一步, 最后手动让当前节点走到其next. 其实就是双指针, 但是移动全靠手动赋值罢了.
不是难题, 甚至没做过也能一下子ac, 不过从链表来看, 还是有价值的题目.