題目
Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
思路
這里是一個很常規的問題，合并k個有序的數組。首先看看合并兩個有序的數組會怎么做，這個問題是不是很熟悉。一下就想到了歸并排序的合并步驟，在兩個數組中設計兩個index，即index1，index2。
a[index1] < b[index2] => c[index1 + index2 - 1] = a[index1], index1 ++
a[index1] >= b[index2] => c[index1 + index2 - 1] = b[index2], index2 ++
如果數組a的長度為n，數組b的長度為m，即O(n+m)的復雜度可以解決這個問題，那么現在2個數組變成了k個數組，我們是不是可以使用同樣的方法呢？
肯定是可以的，不過我們現在是需要在k個索引數中找到最小的一個，并且把它賦值給最終的結果數組，并把索引增加。那這個子問題其實也是很熟悉的一個子問題，動態維護最小值，因為是全段最小，所以我們選用堆來維護。如果是維護區間最小，我們也可以用線段樹來實現。
那么我們只需要在一開始的時候建立一個大小為k的堆（即將每個數組的第一個數加入堆，并從下向上維護一次堆），這里建堆的復雜度為O(klogk)。然后每次將堆頭加入最終的答案數組，并將其換成它的下一個，并從上向下維護一次堆，這里的單此維護代價是O(logk)，總維護代價是O(nlogk)。
代碼
這里是使用鏈表實現的，總體思路不變，比較煩的是判斷空鏈表的情況。
/**
* 交換兩個節點
*
* @param lists
* @param a
* @param b
*/
public void changeNode(ListNode[] lists, int a, int b) {
ListNode c = lists[a];
lists[a] = lists[b];
lists[b] = c;
}
/**
* 向上調整堆
*
* @param heap
* @param root
*/
public void makeHeap(ListNode[] heap, int root) {
if (root == 0) return;
int fa = (root + 1) / 2 - 1;
int change = root % 2 == 0 ? (heap[root - 1].val < heap[root].val ? root - 1 : root) : root;
if (heap[fa].val > heap[change].val) {
changeNode(heap, fa, change);
makeHeap(heap, fa);
}
}
/**
* 向下調整堆
*
* @param heap
* @param l
*/
public void adjustHeapDown(ListNode[] heap, int l) {
int lc = 0, rc = 0, change = 0;
while (l * 2 + 1 < heap.length) {
lc = l * 2 + 1;
rc = l * 2 + 2;
change = rc >= heap.length ? lc : (heap[lc].val < heap[rc].val ? lc : rc);
if (heap[change].val < heap[l].val)
changeNode(heap, l, change);
else
break;
l = change;
}
}
public ListNode mergeKLists(ListNode[] lists) {
if (lists.length == 0 || lists == null) return null;
int len = 0;
for (int i = 0; i < lists.length; i++) {
len += lists[i] != null ? 1 : 0;
}
if (len == 0) return null;
ListNode[] heap = new ListNode[len];
len = 0;
for (int i = 0; i < lists.length; i++) {
if (lists[i] != null) {
heap[len] = lists[i];
makeHeap(heap, len);
len++;
}
}
ListNode ans = heap[0];
ListNode res = ans;
while (true) {
heap[0] = heap[0].next != null ? heap[0].next : new ListNode(Integer.MAX_VALUE);
adjustHeapDown(heap, 0);
if (heap[0].val == Integer.MAX_VALUE) break;
res.next = heap[0];
res = heap[0];
}
return ans;
}
PriorityQueue
因為最近在學習Java，對應該功能的實現，Java中有一種數據結構PriorityQueue。其實底層的實現就是最小堆，相信最小堆的實現大家都很熟悉，這邊就不贅述，這里僅僅記錄一下API。
- 向優先隊列添加元素[O(logn)]：
- add(E e)：插入失敗時，拋出異常
- offer(E e)：插入失敗時，返回false
- 獲取但不刪除隊首元素[O(1)]：
- element()：獲取失敗時，拋出異常
- peek()：獲取失敗時，返回null
- 獲取并且刪除隊首元素[O(logn)]：
- remove()：獲取失敗時，拋出異常
- poll()：獲取失敗時，返回null
- 刪除元素[O(logn)]：
- remove(Object o)：刪除優先隊列中等于o的元素
PriorityQueue的具體分析見：深入理解Java PriorityQueue
