《算法导论》第6章 堆排序 (3)K路归并

问题描述：

问题来自习题6.5-8 给出一个时间为O(nlgk)，用来将k个已排序链表合并为一个排序链表的算法。

此处n为所有输入链表中元素的总数。（提示：用一个最小堆来做k路合并）。

在K路归并问题中，取出最小堆的根元素（最小元素）后，如果此元素没有后继元素（next为空），

则有两种方案：

一、从K路中的另一个链表取出一个元素放到根位置。

二、将堆底部最后一个元素挪到根位置，并将堆大小减一。

此处采用方案二。堆大小每减一，说明K路中某一个链表已处理完。

当堆大小为零时，处理结束。

源码与注释：

// 链表结点类

classNode {

intvalue;

Nodenext;

}

publicclassKMerge {

publicstaticvoidmain(String[] args) {

// 创建五路链表

LinkedList<Node> list1 =createList(2, 5, 8, 10);

LinkedList<Node> list2 =createList(3, 4, 14);

LinkedList<Node> list3 =createList(9, 11, 13, 15, 18);

LinkedList<Node> list4 =createList(7, 12, 17, 22, 25);

LinkedList<Node> list5 =createList(6, 16, 19, 21);

LinkedList<LinkedList<Node>> kLists =newLinkedList<LinkedList<Node>>();

kLists.add(list1);

kLists.add(list2);

kLists.add(list3);

kLists.add(list4);

kLists.add(list5);

// 开始归并

LinkedList<Node> resultList =kMerge(kLists);

for(Node node : resultList) {

System.out.print(node.value+", ");

}

System.out.println();

}

publicstaticLinkedList<Node> kMerge(LinkedList<LinkedList<Node>> kLists) {

intheapSize = kLists.size();

Node[] heap =newNode[heapSize + 1];

// 取出K路中每个链表的第一个元素，用来建堆。

for(inti = 1; i <= heapSize; i++)

heap[i] = kLists.get(i - 1).getFirst();

buildMaxHeap(heap, heapSize);

LinkedList<Node> resultList =newLinkedList<Node>();

while(heapSize > 0) {

// 将根位置的最小元素取出到结果中。

Node minNode = heap[1];

resultList.add(minNode);

// 后继为空，则将堆尾元素挪到根位置。

// 否则将后继元素添加到堆中。

if(minNode.next==null) {

heap[1] = heap[heapSize];

heapSize -= 1;

}

else{

heap[1] = minNode.next;

}

// 根位置的堆性质被破坏，重新恢复。

minHeapify(heap, heapSize, 1);

}

returnresultList;

}

publicstaticvoidbuildMaxHeap(Node[] heap,intheapSize) {

for(inti = heapSize / 2; i >= 1; i--)

minHeapify(heap, heapSize, i);

}

publicstaticvoidminHeapify(Node[] heap,intheapSize,inti) {

intleft = 2 * i;

intright = 2 * i + 1;

intmin = i;

if(left <= heapSize && heap[left].value< heap[i].value)

min = left;

if(right <= heapSize && heap[right].value< heap[min].value)

min = right;

if(min != i) {

Node tmp = heap[i];

heap[i] = heap[min];

heap[min] = tmp;

minHeapify(heap, heapSize, min);

}

}

publicstaticLinkedList<Node> createList(int... values) {

LinkedList<Node> list =newLinkedList<Node>();

Node preNode =null;

for(intvalue : values) {

Node node =newNode();

node.value= value;

if(preNode !=null)

preNode.next= node;

list.add(node);

preNode = node;

}

returnlist;

}

}

效率分析：

堆的大小为K，调用buildMaxHeap()建堆花费KlgK。剩余元素为N - K个。

每次取出根元素，放入后继元素后，调用maxHeapify()保持堆性质花费lgK。

所以总的时间为KlgK + (N - K)lgK = NlgK。