34

Is there an efficient algorithm for merging 2 max-heaps that are stored as arrays?

templatetypedef
  • 362,284
  • 104
  • 897
  • 1,065
ThP
  • 2,312
  • 4
  • 19
  • 25

3 Answers3

23

It depends on what the type of the heap is.

If it's a standard heap where every node has up to two children and which gets filled up that the leaves are on a maximum of two different rows, you cannot get better than O(n) for merge.

Just put the two arrays together and create a new heap out of them which takes O(n).

For better merging performance, you could use another heap variant like a Fibonacci-Heap which can merge in O(1) amortized.

Update: Note that it is worse to insert all elements of the first heap one by one to the second heap or vice versa since an insertion takes O(log(n)). As your comment states, you don't seem to know how the heap is optimally built in the beginning (again for a standard binary heap)

  1. Create an array and put in the elements of both heaps in some arbitrary order
  2. now start at the lowest level. The lowest level contains trivial max-heaps of size 1 so this level is done
  3. move a level up. When the heap condition of one of the "sub-heap"s gets violated, swap the root of the "sub-heap" with it's bigger child. Afterwards, level 2 is done
  4. move to level 3. When the heap condition gets violated, process as before. Swap it down with it's bigger child and process recursively until everything matches up to level 3
  5. ...
  6. when you reach the top, you created a new heap in O(n).

I omit a proof here but you can explain this since you have done most of the heap on the bottom levels where you didn't have to swap much content to re-establish the heap condition. You have operated on much smaller "sub heaps" which is much better than what you would do if you would insert every element into one of the heaps => then, you willoperate every time on the whole heap which takes O(n) every time.

Update 2: A binomial heap allows merging in O(log(n)) and would conform to your O(log(n)^2) requirement.

Etan
  • 17,014
  • 17
  • 89
  • 148
  • "you cannot get better than O(n) for merge" -- what is n, and O(n) of what? It is surely possible to use way fewer comparisons (and data moves) than if you simply put two arrays together and rebuild the heap. – Alexey Mar 11 '23 at 22:17
10

Two binary heaps of sizes n and k can be merged in O(log n * log k) comparisons. See

Jörg-R. Sack and Thomas Strothotte, An algorithm for merging heaps, Acta Informatica 22 (1985), 172-186.

A. Rex
  • 31,633
  • 21
  • 89
  • 96
  • 10
    This requires that the heap be implemented with pointers like a regular pointer-based tree, which is different from the common practice . – phoeagon Oct 01 '13 at 04:22
  • I was going to say the same thing @phoeagon - I started reading it and it says it requires O(k) data operations when it copies one array into another, but at the very end of the paper it points out that if using pointers instead of an array-based heap the data operations can be done in constant time leaving you back with O(log n * log k) operations. – Asaf Oct 18 '18 at 04:37
1

I think what you're looking for in this case is a Binomial Heap.

A binomial heap is a collection of binomial trees, a member of the merge-able heap family. The worst-case running time for a union (merge) on 2+ binomial heaps with n total items in the heaps is O(lg n).

See http://en.wikipedia.org/wiki/Binomial_heap for more information.

jfrattarola
  • 171
  • 6