O(N lgK) 时间内合并K个有序链表

问题:

在O(N lgK) 时间内合并K个有序链表, 这里N指的是K个链表中所有的元素个数。

分析:

这是一道非常经典的面试题,在很多大公司的面试题中,此题频繁出现。这题也是算法导论的作业题。

这题的思路如下:

1) 在每一个链表中取出第一个值,然后把它们放在一个大小为K的数组里,然后把这个数组当成heap,然后把该堆建成最小堆。此步骤的时间复杂度为O(K)

2 )取出堆中的最小值(也是数组的第一个值),然后把该最小值所处的链表的下一个值放在数组的第一个位置。如果链表中有一个已经为空(元素已经都被取出),则改变heap的大小。然后,执行MIN-HEAPIFY操作,此步骤的时间复杂度为O(lg K).

3 ) 不断的重复步骤二,直到所有的链表都为空。

代码如下:

[java]  view plain copy
  1. public void minHeapify(Node[] node, int index, int size) {  
  2.     int left = 2 * index + 1;  
  3.     int right = 2 * index + 2;  
  4.     int smallest;  
  5.       
  6.     if (left < size && node[left].data < node[index].data) {  
  7.         smallest = left;  
  8.     } else {  
  9.         smallest = index;  
  10.     }  
  11.       
  12.     if (right < size && node[right].data < node[smallest].data) {  
  13.         smallest = right;  
  14.     }  
  15.       
  16.     if (smallest != index) {  
  17.         exchange(node, smallest, index);  
  18.         minHeapify(node, smallest, size);  
  19.     }  
  20. }  
创建最小堆:

[java]  view plain copy
  1. public void buildMinHeap(Node[] node, int size) {  
  2.     for (int i = size / 2 - 1; i >= 0; i--) {  
  3.         minHeapify(node, i, size);  
  4.     }  
  5. }  
合并:

[java]  view plain copy
  1. public Node mergeKSortedList(Node[] heads) {  
  2.         Node head = null// the head of the merged list  
  3.         Node current = null;  
  4.         int size = heads.length;  
  5.         Node[] heap = new Node[heads.length]; // create a heap  
  6.         // initialize the value of the heap  
  7.         for (int i = 0; i < heads.length; i++) {  
  8.             heap[i] = heads[i];  
  9.             heads[i] = heads[i].next;  
  10.         }  
  11.         // create a min heap  
  12.         buildMinHeap(heap, size);  
  13.           
  14.         int tempSize = size;  
  15.         while (size > 0) {  
  16.             if (head == null) {  
  17.                 head = heap[0];  
  18.                 current = head;  
  19.             } else {  
  20.                 current.next = heap[0];  
  21.                 current = current.next;  
  22.             }  
  23.             if (heap[0].next == null) {  
  24.                 size--;  
  25.             } else {  
  26.                 heap[0] = heap[0].next;  
  27.             }  
  28.               
  29.             // if the size of heap changes, we need to move all the elements in the heap to  
  30.             // the front of the heap  
  31.             if (size != tempSize) {  
  32.                 for (int i = 0; i < size; i++) {  
  33.                     heap[i] = heap[i+1];  
  34.                 }  
  35.                 tempSize = size;  
  36.             }  
  37.             minHeapify(heap, 0, size);  
  38.         }  
  39.         return head;  
  40.     }  

你可能感兴趣的:(数据结构)