CS352: Heaps [F'98]

CS352 Data Structures

d-Heaps

Like binary heaps except all nodes have d children. A binary heap is a 2-heap.

Example:

more shallow than a binary heap; thus, inserts are O(logd n)
delete_min more expensive : O(d logd n).

-- search for minimum of d children takes d-1 comparisons

-- in array, multiplications and divisions used to find children and parents are by d, so division by bit shift no longer possible.

structure can be used when priority queue too large for memory; same advantages as B-trees.

Mergeable Heaps

Addresses disadvantage of heaps: merging two heaps into one (necessary if, e.g., a server goes down and queued jobs must be merged in to queue for another server)

merging two heaps requires O(n) time for equal-size heaps, since one array must be copied into another in a merge
data structures that support efficient merging use pointers, which slow down other operations; however, leftist heaps, skew heaps and binomial queues support efficient merging using pointers

Leftist Heaps

Have same structure and ordering property as binary heaps

Are binary trees, but are very unbalanced

use Null Path Length (npl) as part of definition:

npl(x) of any node x is the length of the shortest path from x to a node without two children

--npl(node with 0 or 1 child) = 0

--npl(nil) = -1

leftist not leftist

Leftist Heap Property: for every node x in the heap, the npl of left child is at least (>)as large as that of the right child.

Heap property ensures that tree will become deep towards the left ("leftist" heap)

The right path is as short as any path in the heap

A leftist heap with r nodes on the right path has at least 2r - 1 nodes (Thm. proof on p.190)

-- A leftist tree of n nodes has a right path containing at most | log(n+1) | nodes

Operations of leftist heaps perform all the work on the right path, which is guaranteed to be as short as any in the heap (thus minimizing merge time). Leftist heap property must be restored if necessary

Merging

Fundamental operation on leftist heaps. Time to merge is O(log n).

Recursively merge heap with larger root with right subheap of the heap with smaller root.
Base case is: right subheap is nil.
Backing out of recursion, attach subheap with larger root as right child of heap with smaller root

Non-recursive merge

requires two passes

(a) arrange node on right paths of each heap in sorted order, keeping respective left children

(b) swap all children which violate leftist heap property

i.e., 1. follow rt. child of each heap and line up nodes in order

2. attach left subtrees of each node in the "line" and swap, if necessary, starting at

bottom(check npl)

Insertions

Let item to be inserted be one-node heap; merge with larger heap.

template <class element_type>

void Left_Heap<element_type>:: insert(element_type & x);

{

//create a node of element_type

P = new Left_Node<element_type> (x);

if( P == NULL) Error("Out of Space");

root = merge(P,H);

}

Delete_min

Destroy the root, creating two heaps; merge

time complexity of O(log n)

template <class element_type>

element_type Left_Heap<element_type>:: delete_min();

{

//declarations etc

...

min_element = root->element;

Left_Heap = root->left;

Right_Heap = root->right;

delete root;

root = merge(Left_Heap,Right_Heap);

return min_element;

}

NOTE: Interfaces for both routines are same as for binary heap implementation. Either PQ package can be used, with implementation being transparent to calling routine.

Build_Leftist_Heap

Consider each element as a one-node leftist heap

Place all the heaps in a queue
Until only one heap is on the queue, dequeue two heaps, merge them, and enqueue the result
O(n) algorithm

SKEW HEAPS

Self-adjusting version of leftist heap (analagous to splay vs AVL)

Binary trees with heap order but no info kept about null path length

Right path of skew heap can be arbitrarily long at any time

-- worst case running time is O(n)

For any m consecutive ops, total worst-case time is O(m lg n); thus, amortized cost

per op = O(lg n)

Merge operation same as for leftist heaps except: left and right children always are swapped except for smallest node on right path

Advantage of skew heaps: no extra space needed to keep path lengths and no test to determine when to swap children

Binomial Queues

Improvement over leftist heaps

Support insertion, merging and delete_min in O(log n) worst case time

Insertion is O(1) on average

Structure

a collection of heap-ordered trees (a forest)

-- each tree is a binomial tree

there is at most one binomial tree of every height

-- binomial tree of height 0 is a one-node tree

a binomial tree, Bk, of height k is formed by attaching a binomial tree Bk-1 to the root of another binomial tree, Bk-1 (e.g. B2 merged with B2 yields B3)

Binomial trees of height k have exactly 2^k nodes;if number of elements in the tree is != 2^k, merge is required

number of nodes at depth d is ,which is (k! / ( (k-d)! d! ) )
Priority queue of any size can be represented by a collection of binomial trees if no more than one binomial tree of any height is allowed (heap order imposed on binomial trees)

-- PQ of size 6 => forest of B1 and B2 (0110 in binary: B1 and B2 are present in structure, but not B0 and B3)

-- Example: binomial queues with six elements:

Binomial Queue Operations

findMin

The minimum element is found by scanning the roots of all trees in the forest. There are log n different trees in a queue. Thus, the findMin is done in O(log n) time. The operation can be done in O(1) if the min is updated during other operations and we keep track of it.

Merging

trees in binomial queue are kept sorted by height
new queue contains all binomial trees of unique heights and the merge of trees having the same heights
O(log n) worst case

Insertion

special case of merging
create a one-node tree and perform merge
The following priority queue results from insertion of the nodes 1 through 7

If PQ has property that smallest nonexistent binomial tree is Bi, running time is proportional

to i+1.

Ex. inserting 8 above will terminate in 4 steps since B3 is smallest tree that is not in the queue

Add 8 to 7 --> B1
add B1 to B1 --> B2
add B2 to B2 --> B3

After inserting 8

Performing n inserts on initially empty bin. queue is O(n) in worst case
Since each tree in binomial queue is present with prob. 1/2 then we expect insertion to terminate in 2 steps. This implies the average insertion time is O(1)

Deletion

DeleteMin operation first finds the binomial tree with the smallest root. This tree, B_k, is removed from the forest of trees, it's root is removed, and the resulting priority queue is merged with the original priority queue.

It take O(log n) time to find the minimum tree and to create the 2 queues to merge; merging takes O(log n) time. Hence, deleteMin takes O(log n).

Implementation

circular linked list is used to represent

each node in tree contains data, first child, left and right sibling, and number of children (rank)

Applications of Priority Queues

Selection Problem Revisited

Find the kth largest element in a list of n elements

Two inefficient algorithms

1. (a) Read n numbers into array and sort in decreasing order;

(b) Return element in position k Running time is algorithmic using simple sort algorithm

2. (a) Read first k elements into array and sort in decr. order
   (b) Examine each remaining element in list, one at a time
   (c) If element is larger than k, insert in proper position of array, bumping one element out.
   (d) When done, kth position is answer

Running time is O(n.k). For each element left, k shifts are made in worst case to insert the element into proper place.

Two efficient algorithms using priority queues run in On log n) when k = |n/2|

(a) Find kth SMALLEST element (kth largest is found by using a MaxHeap) let k = 4

(i) read n elements into array: 1,16,32,12,8,54,9,0,25,17

(ii) build heap

(iii) perform k delete_min operations

(iv) last element taken from heap is answer

-- worst-case time is O(n + k log n) :

O(n) to build heap + O(log n) for each of k delete_mins

(b) Find kth LARGEST element

let k = 4

list = 1,16,32,12,8,54,9,0,25,17

(i) Maintain a set S of the k largest elements

(ii) After the first k elements are read, each successive element read is compared with

kth largest element, denoted S_k.

S = {1,16,32,12} S_k = 1

(d) Inspect each remaining element in list; if new element > Sk then it replaces Sk in S

(e) S then has a new smallest element

(f) At end of input list, return smallest element in S as answer

Time analysis:

first k elements are inserted into heap in O(k) time
Time to process each remaining element is O(1) to compare + O(log k) to delete Sk and insert new element if necessary.

mullinsj@umkc.edu