Priority Queues and Heaps

1
Priority Queues and Heaps
2
Priority Queues

• We already know a standard queue
• Elements can only be added to the start of the
  queue
• Elements can only be removed from the end of the
  queue
• Order of removal is FIFO (first in, first out)

3
Priority Queues

• In a Priority Queue, each element is assigned a
  priority as well
• A priority is a numeric value the lower the
  number, the higher the priority
• Elements are removed in order of their priority
  no longer FIFO
• Can still add elements in any order

4
Priority Queues

• public interface PriorityQueueltTgt
• void add(T element)
• T remove()
• T peek()

5
Priority Queues

• The interface to a priority queue is almost the
  same as to a regular queue
• However, elements in the queue must now be of the
  type Comparable (i.e. implement the interface)
• The remove method always returns the element with
  highest priority (lowest numeric value)

6
Priority Queues

• A Priority Queue is an abstract data structure,
  which can be implemented in various ways
• Linked list, removal will be O(n)
• Binary search tree, removal will usually be
  O(log(n)), but not always
• Heap, removal will always be O(log(n))

7
Heaps

• A Heap is a Binary Tree, but not a Binary Search
  Tree
• In order for a Binary Tree to be a Heap, two
  conditions must be fulfilled
• A heap is almost complete only nodes missing in
  bottom layer
• All nodes store values which are at most as large
  as the values stored in any descendant

8
Heaps
9
Heaps

• On a heap, only two operations are of interest
• Insert a new element
• Remove the element with lowest value, i.e. the
  root element
• However, both of these operations must preserve
  the heap property of the tree

10
Heaps - insertion
23
32
29
42
56
37
Find an empty slot in the tree
11
Heaps - insertion
23
32
29
42
If the value in the parent is larger than the new
value, swap the parent and the new slot (repeat
this)
56
37
12
Heaps - insertion
23
32
29
32
56
37
42
Now insert the new value
13
Heaps - insertion

• Since the heap is almost complete, the number
  of layers in a tree with n nodes is at most
  (log(n) 1)
• Each swap operation can be done in constant time,
  so insertion of an element has the run-time
  complexity O(log(n))

14
Heaps - removal
Remove the root node (always smallest)
23
29
32
56
37
42
15
Heaps - removal
29
32
Move the last element into the root position
56
37
42
16
Heaps - removal
If any child has a lower value, swap position
with child with lowest value (repeat this)
42
29
32
56
37
17
Heaps - removal
If any child has a lower value, swap position
with child with lowest value (repeat this)
29
42
32
56
37
18
Heaps - removal
The heap property has now been reestablished This
is known as fixing the heap
29
37
32
56
42
19
Heaps - removal

• Since the heap is almost complete, the number
  of layers in a tree with n nodes is at most
  (log(n) 1)
• Each swap operation can be done in constant time,
  so deletion of an element has the run-time
  complexity O(log(n))

20
Heaps - removal

• The important point is that for a heap, we are
  guaranteed O(log(n)) run time for insertion and
  deletion
• This cannot be guaranteed for a binary search
  tree
• A binary search tree can degenerate into a
  linked list a heap cannot

21
Heaps - representation

• Due to the regularity of a heap, it can
  efficiently be stored in an array
• Root node is stored in position 1 (not 0)
• A node in position i has its children stored in
  position 2i and (2i 1)
• A node in position i has its parent stored in
  position i/2 (integer division)
• When running out of space, double the size

22
Heapsort

• A heap can be used for a quite efficient way of
  sorting an array of n objects
• Run-time complexity of O(nlog(n))
• Does not use extra space
• Main steps
• Turn the array into a heap
• Repeatedly remove the root element (which has the
  smallest value)

23
Heapsort

• In order to turn the array into a heap, we could
  just insert all the elements into a new heap
• However, we can do this without using an extra
  heap!
• We use the fix heap procedure from the bottom
  in the tree and upwards

24
Heapsort

• Why will this work?
• Remember that the fix heap procedure takes two
  subheaps as input, plus a root node with a
  wrong value
• If we work from the bottom and up, the input will
  always be like above

25
Heapsort
Fix heap here
Fix heaps here
Fix heaps here
Trivially a heap
26
Heapsort

• Now the tree is a heap
• Repeatedly remove the root from the heap, and fix
  the remaining heap
• We remove the root by placing it at the end of
  the array, beyond the last element in the
  remaining heap

27
Heapsort
23
29
32
56
37
42
23
29
32
37
56
42
28
Heapsort
29
32
56
37
42
29
32
37
56
42
23
29
Heapsort
29
37
32
56
42
29
37
32
42
56
23
30
Heapsort
37
32
56
42
37
32
42
56
29
23
31
Heapsort
32
37
56
42
32
37
56
42
29
23
32
Heapsort
37
56
42
37
56
42
32
29
23
33
Heapsort
37
42
56
37
42
56
32
29
23
34
Heapsort
42
56
42
56
37
32
29
23
35
Heapsort
42
56
42
56
37
32
29
23
36
Heapsort
56
56
42
37
32
29
23
37
Heapsort
56
56
42
37
32
29
23
38
Heapsort
56
42
37
32
29
23
39
Heapsort

• One minor issue numbers are sorted in wrong
  order
• Could just reverse order, takes O(n)
• Or use max-heap
• Min-heap All nodes store values at most as large
  as the values stored in any descendant
• Max-heap All nodes store values at least as
  large as the values stored in any descendant