合并两个有序链表:
给你输入两个有序链表,请你把他俩合并成一个新的有序链表:
核心代码如下:
public class ListNode {
int val;
ListNode next;
ListNode() {}
ListNode(int val) { this.val = val; }
ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}
class Solution{
public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
ListNode dummy = new ListNode(-1), p=dummy;
ListNode p1=list1,p2=list2;
while (p1!=null&&p2!=null){
if (p1.val> p2.val){
p.next=p2;
p2=p2.next
}else{
p.next=p1;
p1=p1.next;
}
p=p.next;
}
if (p1!=null){
p.next=p1;
}
if (p2!=null){
p.next=p2;
}
return dummy.next;
}
}
合并 k 个有序链表
核心代码
public ListNode mergeKLists(ListNode[] lists) {
ListNode dummy = new ListNode(-1), p=dummy;
PriorityQueue<ListNode> priorityQueue = new PriorityQueue<>(lists.length,(a,b)->(a.val-b.val));
for (ListNode list : lists) {
if (list!=null)
priorityQueue.add(list);
}
while (!priorityQueue.isEmpty()){
ListNode node=priorityQueue.poll();
p.next=node;
if (node.next!=null){
priorityQueue.add(node.next);
}
p=p.next;
}
return dummy.next;
}
讲解:优先队列 pq
中的元素个数最多是 k
,所以一次 poll
或者 add
方法的时间复杂度是 O(logk)
;所有的链表节点都会被加入和弹出 pq
,所以算法整体的时间复杂度是 O(Nlogk)
,其中 k
是链表的条数,N
是这些链表的节点总数。
单链表的倒数第 k 个节点
从前往后寻找单链表的第 k
个节点很简单,一个 for 循环遍历过去就找到了,但是如何寻找从后往前数的第 k
个节点呢?
那你可能说,假设链表有 n
个节点,倒数第 k
个节点就是正数第 n - k + 1
个节点,不也是一个 for 循环的事儿吗?
是的,但是算法题一般只给你一个 ListNode
头结点代表一条单链表,你不能直接得出这条链表的长度 n
,而需要先遍历一遍链表算出 n
的值,然后再遍历链表计算第 n - k + 1
个节点。
也就是说,这个解法需要遍历两次链表才能得到出倒数第 k
个节点。
那么,我们能不能只遍历一次链表,就算出倒数第 k
个节点?可以做到的,如果是面试问到这道题,面试官肯定也是希望你给出只需遍历一次链表的解法。
这个解法就比较巧妙了,假设 k = 2
,思路如下:
首先,我们先让一个指针 p1
指向链表的头节点 head
,然后走 k
步:
现在的 p1
,只要再走 n - k
步,就能走到链表末尾的空指针了对吧?
趁这个时候,再用一个指针 p2
指向链表头节点 head
:
接下来就很显然了,让 p1
和 p2
同时向前走,p1
走到链表末尾的空指针时前进了 n - k
步,p2
也从 head
开始前进了 n - k
步,停留在第 n - k + 1
个节点上,即恰好停链表的倒数第 k
个节点上
这样,只遍历了一次链表,就获得了倒数第 k
个节点 p2
核心代码如下
// 返回链表的倒数第 k 个节点
ListNode findFromEnd(ListNode head, int k) {
ListNode p1 = head;
// p1 先走 k 步
for (int i = 0; i < k; i++) {
p1 = p1.next;
}
ListNode p2 = head;
// p1 和 p2 同时走 n - k 步
while (p1 != null) {
p2 = p2.next;
p1 = p1.next;
}
// p2 现在指向第 n - k 个节点
return p2;
}
很多链表相关的算法题都会用到这个技巧
解法代码:
// 主函数
public ListNode removeNthFromEnd(ListNode head, int n) {
// 虚拟头结点
ListNode dummy = new ListNode(-1);
dummy.next = head;
// 删除倒数第 n 个,要先找倒数第 n + 1 个节点
ListNode x = findFromEnd(dummy, n + 1);
// 删掉倒数第 n 个节点
x.next = x.next.next;
return dummy.next;
}
private ListNode findFromEnd(ListNode head, int k) {
// 代码见上文
}
这个逻辑就很简单了,要删除倒数第 n
个节点,就得获得倒数第 n + 1
个节点的引用,可以用我们实现的 findFromEnd
来操作。
不过注意我们又使用了虚拟头结点的技巧,也是为了防止出现空指针的情况,比如说链表总共有 5 个节点,题目就让你删除倒数第 5 个节点,也就是第一个节点,那按照算法逻辑,应该首先找到倒数第 6 个节点。但第一个节点前面已经没有节点了,这就会出错。
但有了我们虚拟节点 dummy
的存在,就避免了这个问题,能够对这种情况进行正确的删除。