- Related Questions & Answers
- Meldable Priority Queues and Skew Heaps
- The Priority Queue in Javascript
- Double Ended Priority Queue (DEPQ)
- Multithreaded Priority Queue in Python
- Creating a Priority Queue using Javascript
- C++ Program to Implement Priority Queue
- Priority Queue Introduction in C/C++
- Dequeue and Priority Queue in C++
- Priority Queue using Linked List in C
- How to Implement Priority Queue in Python?
- Double ended priority queue in C++ Program
- Priority Queue using doubly linked list in C++
- Priority Queue in C++ Standard Template Library (STL)
- Meldable DEPQs
- Operations on Queue in Data Structures

- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who

The randomized meldable heap(also called as Meldable Priority Queue) supports a number of common operations. These are known as insertion, deletion, and a searching operation, findMin. The insertion and deletion operations are implemented in terms of an additional operation specific to the meldable heap, Meld(A1, A2).

The basic target of the meld (also called as merge) operation is to take two heaps (by taking each heaps root nodes), A1 and A2, and merges them, returning a single heap node as a result. This heap node is the root node of a heap containing all elements from the two subtrees rooted at A1 and A2.

An excellent feature of this meld operation is that it can be defined recursively. If either heaps are associated with null value, then the merge is accomplished with an empty set and the method returns the root node of the non-empty heap. If both A1 and A2 are not nil, check if A1 > A2. If it is, swap the two. It is therefore ensured that A1 < A2 and that the root node of the merged heap will contain A1. We then recursively merge A2 with A1.left or A1.right. This step is where the randomization comes in as this decision of which side to merge with is decided by a coin toss.

function Meld(Node A1, Node A2) if A1 is nil => return A2 if A2 is nil => return A1 if A1 > A2 => swap A1 and A2 if coin_toss is 0 => A1.left = Meld(A1.left, A2) else A1.right = Meld(A1.right, A2) return A1

With the meld operation complete, inserting into the meldable heap is so simple. First, a new node, a, is created containing the value p. This new node is then simply merged with the heaps root node.

function Insert(p) Node a = new Node a.p = p root = Meld(a, root) root.parent = nil increment node count

Same as easy to the insert operation, Remove() implements the Meld operation to eliminate the root node from the heap. This is accomplished by simply melding the two children of the root node and making the returned node as the new root.

function Remove() rootNode = Meld(rootNode.left, rootNode.right) if rootNode is not nil => rootNode.parent = nil decrement node count

Possibly the simplest operation for the randomized meldable heap, FindMin() simply returns the present element stored in the heap's root node.

**Additional Operations**

Some extra operations that can be applied for the meldable heap that also have O(logn) worst-case efficiency are −

- Remove(a) - Remove the node a and its key from the heap.
- Absorb(P) - Sum all elements of the meldable heap P to this heap, emptying P in the process.
- DecreaseKey(a, q) - Decreases the key in node a to q (pre-condition: q <= a.p).

Advertisements