Heap - Đưa ra thuật toán thời gian

Rất có thể, câu hỏi này được hỏi trước. Đó là từ vấn đề CLRS (2nd Ed) 6.5-8 -

Đưa ra thuật toán thời gian để hợp nhất các danh sách được sắp xếp vào một danh sách được sắp xếp, trong đó là tổng số phần tử trong tất cả các danh sách đầu vào. (Gợi ý: Sử dụng một đống nhỏ để hợp nhất -way.)$O(n \lg k)$$k$$n$$k$

Vì có danh sách được sắp xếp và tổng số giá trị, chúng ta giả sử mỗi danh sách chứa các số , hơn nữa, mỗi danh sách được sắp xếp theo thứ tự tăng dần và kết quả cũng sẽ được lưu theo thứ tự tăng dần đặt hàng.$k$$n$$\frac{n}{k}$

Mã giả của tôi trông như thế này -

    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

Độ phức tạp tổng thể của tôi trở thành . Tôi không thể tìm thấy bất kỳ cách nào để tránh vòng lặp bên trong vòng lặp để tìm phần tử tối thiểu tiếp theo từ danh sách k. Có cách nào khác không? Làm thế nào để có được thuật toán ?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)$

Mục đích của heap là cung cấp cho bạn mức tối thiểu, vì vậy tôi không chắc mục đích của vòng lặp for này là gì - for j := 2 to k.

Tôi nhận mã giả:

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)

Tổng mức độ phức tạp thời gian là do đó $O(k * \log k + n * 2 \log k) = O(n \log k)$

Bạn cũng có thể, thay vì deleteMinvà insert, có getMin( ) và ( O ( log k ) ), điều này sẽ làm giảm hệ số không đổi, nhưng không phức tạp.$O(1)$incrementIndex$O(\log k)$

Ví dụ:
(sử dụng giá trị thay vì chỉ mục và chỉ mục danh sách và heap được biểu diễn dưới dạng mảng được sắp xếp cho rõ ràng)

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

Trước hết, tôi nghĩ rằng giả định của bạn về tất cả các danh sách có mục nhập là không hợp lệ nếu thời gian chạy của thuật toán phụ thuộc vào độ dài của danh sách dài nhất .$n/k$

Đối với vấn đề của bạn, thuật toán sau nên thực hiện thủ thuật:

1. Đặt các phần tử đầu tiên của danh sách trong một h-min có kích thước k . Hãy nhớ cho mỗi phần tử danh sách l m nó thuộc về. ( O ( k lg k ) )$H$$k$$l_m$$O(k\lg k)$
2. Đối với từ 1 đến n làm: $i$$1$$n$
   • Trích xuất tối thiểu từ H và lưu trữ trong r e s u l t [ i ] ( O ( lg k ) )$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]$