Heap - Geben Sie einen

Höchstwahrscheinlich wird diese Frage schon einmal gestellt. Es ist aus CLRS (2nd Ed) Problem 6.5-8 -

Geben Sie einen -Zeitalgorithmus an, um sortierte Listen zu einer sortierten Liste zusammenzuführen, wobei die Gesamtzahl der Elemente in allen Eingabelisten ist. (Hinweis: Verwenden Sie einen Min-Heap für die Way-Zusammenführung.)$O(n \lg k)$$k$$n$$k$

Da es sortierte Listen und insgesamt Werte gibt, nehmen wir an, dass jede Liste Zahlen enthält. Außerdem wird jede Liste in streng aufsteigender Reihenfolge sortiert und die Ergebnisse werden auch in aufsteigender Reihenfolge gespeichert bestellen.$k$$n$$\frac{n}{k}$

Mein Pseudocode sieht so aus -

    list[k]   ; k sorted lists
    heap[k]   ; an auxiliary array to hold the min-heap
    result[n] ; array to store the sorted list
    for i := 1 to k                 ; O(k)
    do
        heap[i] := GET-MIN(list[i]) ; pick the first element 
                                    ; and keeps track of the current index - O(1)
    done
    BUILD-MIN-HEAP(heap) ; build the min-heap - O(k)
    for i := 1 to n
    do
        array[i] := EXTRACT-MIN(heap)   ; store the min - O(logk)
        nextMin := GET-MIN(list[1])     ; get the next element from the list 1 - O(1)
        ; find the minimum value from the top of k lists - O(k)
        for j := 2 to k                 
        do
            if GET-MIN(list[j]) < nextMin
                nextMin := GET-MIN(list[j]) 
        done
        ; insert the next minimum into the heap - O(logk)
        MIN-HEAP-INSERT(heap, nextMin)
    done

Meine Gesamtkomplexität wird . Ich konnte keinen Weg finden, die -Schleife innerhalb der -Schleife zu umgehen , um das nächste minimale Element aus k-Listen zu finden. Gibt es einen anderen Weg? Wie bekomme ich einen -Algorithmus?O ( k ) O ( n ) O ( n lg k $O(k) + O(k) + O(n(k + 2 \lg k)) \approx O(nk+n \lg k) \approx O(nk)$$O(k)$$O(n)$$O(n \lg k)$

Der Zweck des Heaps ist es, Ihnen das Minimum zu geben, daher bin ich mir nicht sicher, was der Zweck dieser for-Schleife ist for j := 2 to k.

Meine Einstellung zum Pseudocode:

lists[k][?]      // input lists
c = 0            // index in result
result[n]        // output
heap[k]          // stores index and applicable list and uses list value for comparison
                 // if i is the index and k is the list
                 //   it has functions - insert(i, k) and deleteMin() which returns i,k
                 // the reason we use the index and the list, rather than just the value
                 //   is so that we can get the successor of any value

// populate the initial heap
for i = 1:k                   // runs O(k) times
  heap.insert(0, k)           // O(log k)

// keep doing this - delete the minimum, insert the next value from that list into the heap
while !heap.empty()           // runs O(n) times
  i,k = heap.deleteMin();     // O(log k)
  result[c++] = lists[k][i]
  i++
  if (i < lists[k].length)    // insert only if not end-of-list
    heap.insert(i, k)         // O(log k)

Die Gesamtzeitkomplexität ist somit $O(k * \log k + n * 2 \log k) = O(n \log k)$

Sie können auch anstelle von deleteMinund insertein getMin( ) und ein ( O ( log k ) ) haben, wodurch der konstante Faktor, aber nicht die Komplexität verringert wird.$O(1)$incrementIndex$O(\log k)$

Beispiel:
(Verwenden von Wert anstelle von Index und Listenindex und Heap, der der Übersichtlichkeit halber als sortiertes Array dargestellt wird)

Input: [1, 10, 15], [4, 5, 6], [7, 8, 9]

Initial heap: [1, 4, 7]

Delete 1, insert 10
Result: [1]
Heap: [4, 7, 10]

Delete 4, insert 5
Result: [1, 4]
Heap: [5, 7, 10]

Delete 5, insert 6
Result: [1, 4, 5]
Heap: [6, 7, 10]

Delete 6, insert nothing
Result: [1, 4, 5, 6]
Heap: [7, 10]

Delete 7, insert 8
Result: [1, 4, 5, 6, 7]
Heap: [8, 10]

Delete 8, insert 9
Result: [1, 4, 5, 6, 7, 8]
Heap: [9, 10]

Delete 9, insert nothing
Result: [1, 4, 5, 6, 7, 8, 9]
Heap: [10]

Delete 10, insert 15
Result: [1, 4, 5, 6, 7, 8, 9, 10]
Heap: [15]

Delete 15, insert nothing
Result: [1, 4, 5, 6, 7, 8, 9, 10, 15]
Heap: []

Done

Zunächst denke ich, dass Ihre Annahme, dass alle Listen Einträge haben, nicht gültig ist, wenn die Laufzeit des Algorithmus von der Länge der längsten Liste abhängt .$n/k$

Für Ihr Problem sollte der folgende Algorithmus den Trick ausführen:

1. $H$$k$$l_m$$O(k\lg k)$
2. $i$$1$$n$
   • $m$$H$$result[i]$$O(\lg k)$
   • $m$$l_m$$H$$O(\lg k)$

$O(k\lg k + n \lg k)=O(n\lg k)$$result$

$i$$result$$H$$i$$result[1..i]$$i$

$result$$H$$result$$r_1$$l$$r_1$$l[1]$$r_1$$r_1$$l[1] < r_1$$r_1$$result$

$i$$r_i$$H$$H$$m$$l$$l$$H$$result$$r_i$$m$$l$$l$

$result[1..n]$