Priority Queues

1
Priority Queues

• Two kinds of priority queues
• Min priority queue.
• Max priority queue.

2
Min Priority Queue

• Collection of elements.
• Each element has a priority or key.
• Supports following operations
• empty
• size
• insert an element into the priority queue (push)
• get element with min priority (top)
• remove element with min priority (pop)

3
Max Priority Queue

• Collection of elements.
• Each element has a priority or key.
• Supports following operations
• empty
• size
• insert an element into the priority queue (push)
• get element with max priority (top)
• remove element with max priority (pop)

4
Complexity Of Operations

• Two good implementations are heaps and leftist
  trees.
• empty, size, and top gt O(1) time
• insert (push) and remove (pop) gt O(log n) time
  where n is the size of the priority queue

5
Applications

• Sorting
• use element key as priority
• insert elements to be sorted into a priority
  queue
• remove/pop elements in priority order
• if a min priority queue is used, elements are
  extracted in ascending order of priority (or key)
• if a max priority queue is used, elements are
  extracted in descending order of priority (or key)

6
Sorting Example

• Sort five elements whose keys are 6, 8, 2, 4, 1
  using a max priority queue.
• Insert the five elements into a max priority
  queue.
• Do five remove max operations placing removed
  elements into the sorted array from right to left.

7
After Inserting Into Max Priority Queue
6
8
4
Max Priority Queue
1
2

• Sorted Array

8
After First Remove Max Operation
6
4
Max Priority Queue
1
2
8

• Sorted Array

9
After Second Remove Max Operation
4
Max Priority Queue
1
2
8
6

• Sorted Array

10
After Third Remove Max Operation
Max Priority Queue
1
2
8
6
4

• Sorted Array

11
After Fourth Remove Max Operation
Max Priority Queue
1
8
6
4
2

• Sorted Array

12
After Fifth Remove Max Operation
Max Priority Queue
8
6
4
2
1

• Sorted Array

13
Complexity Of Sorting

• Sort n elements.
• n insert operations gt O(n log n) time.
• n remove max operations gt O(n log n) time.
• total time is O(n log n).
• compare with O(n2) for sort methods of Chapter 2.

14
Heap Sort

• Uses a max priority queue that is implemented as
  a heap.
• Initial insert operations are replaced by a heap
  initialization step that takes O(n) time.

15
Machine Scheduling

• m identical machines (drill press, cutter,
  sander, etc.)
• n jobs/tasks to be performed
• assign jobs to machines so that the time at which
  the last job completes is minimum

16
Machine Scheduling Example

• 3 machines and 7 jobs
• job times are 6, 2, 3, 5, 10, 7, 14
• possible schedule

6
13
A
2
7
21
B
3
13
C
time -----------gt
17
Machine Scheduling Example
6
13
A
2
7
21
B
3
13
C
time -----------gt

• Finish time 21
• Objective Find schedules with minimum finish
  time.

18
LPT Schedules

• Longest Processing Time first.
• Jobs are scheduled in the order
• 14, 10, 7, 6, 5, 3, 2
• Each job is scheduled on the machine on which it
  finishes earliest.

19
LPT Schedule

• 14, 10, 7, 6, 5, 3, 2

14
16
A
10
15
B
7
13
16
C
Finish time is 16!
20
LPT Schedule

• LPT rule does not guarantee minimum finish time
  schedules.
• (LPT Finish Time)/(Minimum Finish Time) lt 4/3 -
  1/(3m) where m is number of machines.
• Usually LPT finish time is much closer to minimum
  finish time.
• Minimum finish time scheduling is NP-hard.

21
NP-hard Problems

• Infamous class of problems for which no one has
  developed a polynomial time algorithm.
• That is, no algorithm whose complexity is O(nk)
  for any constant k is known for any NP-hard
  problem.
• The class includes thousands of real-world
  problems.
• Highly unlikely that any NP-hard problem can be
  solved by a polynomial time algorithm.

22
NP-hard Problems

• Since even polynomial time algorithms with degree
  k gt 3 (say) are not practical for large n, we
  must change our expectations of the algorithm
  that is used.
• Usually develop fast heuristics for NP-hard
  problems.
• Algorithm that gives a solution close to best.
• Runs in acceptable amount of time.
• LPT rule is good heuristic for minimum finish
  time scheduling.

23
Complexity Of LPT Scheduling

• Sort jobs into decreasing order of task time.
• O(n log n) time (n is number of jobs)
• Schedule jobs in this order.
• assign job to machine that becomes available
  first
• must find minimum of m (m is number of machines)
  finish times
• takes O(m) time using simple strategy
• so need O(mn) time to schedule all n jobs.

24
Using A Min Priority Queue

• Min priority queue has the finish times of the m
  machines.
• Initial finish times are all 0.
• To schedule a job remove machine with minimum
  finish time from the priority queue.
• Update the finish time of the selected machine
  and insert the machine back into the priority
  queue.

25
Using A Min Priority Queue

• m put operations to initialize priority queue
• 1 remove min and 1 insert to schedule each job
• each insert and remove min operation takes O(log
  m) time
• time to schedule is O(n log m)
• overall time is
• O(n log n n log m) O(n log (mn))

26
Huffman Codes

• Useful in lossless compression.
• May be used in conjunction with LZW method.
• Read from text.

27
Min Tree Definition

• Each tree node has a value.
• Value in any node is the minimum value in the
  subtree for which that node is the root.
• Equivalently, no descendent has a smaller value.

28
Min Tree Example
2
4
9
3
4
8
7
9
9

• Root has minimum element.

29
Max Tree Example
9
4
9
8
4
2
7
3
1

• Root has maximum element.

30
Min Heap Definition

• complete binary tree
• min tree

31
Min Heap With 9 Nodes

• Complete binary tree with 9 nodes.

32
Min Heap With 9 Nodes

• Complete binary tree with 9 nodes that is also a
  min tree.

33
Max Heap With 9 Nodes

• Complete binary tree with 9 nodes that is also a
  max tree.

34
Heap Height

• Since a heap is a complete binary tree, the
  height of an n node heap is log2 (n1).

35
A Heap Is Efficiently Represented As An Array
9
8
7
6
7
2
6
5
1
1
2
3
4
5
6
7
8
9
10
0
36
Moving Up And Down A Heap
37
Inserting An Element Into A Max Heap

• Complete binary tree with 10 nodes.

38
Inserting An Element Into A Max Heap
9
8
7
6
7
2
6
5
1
7
5

• New element is 5.

39
Inserting An Element Into A Max Heap
9
8
7
6
2
6
7
7
5
1
7

• New element is 20.

40
Inserting An Element Into A Max Heap
9
8
7
6
2
6
7
5
1
7
7

• New element is 20.

41
Inserting An Element Into A Max Heap
9
7
8
6
2
6
7
5
1
7
7

• New element is 20.

42
Inserting An Element Into A Max Heap
20
9
7
8
6
2
6
7
5
1
7
7

• New element is 20.

43
Inserting An Element Into A Max Heap
20
9
7
8
6
2
6

7
5
1
7
7

• Complete binary tree with 11 nodes.

44
Inserting An Element Into A Max Heap
20
9
7
8
6
2
6

7
5
1
7
7

• New element is 15.

45
Inserting An Element Into A Max Heap
20
9
7
6
2
6
8
8
7
5
1
7
7

• New element is 15.

46
Inserting An Element Into A Max Heap
20
7
15
6
2
6
9
8
8
7
5
1
7
7

• New element is 15.

47
Complexity Of Insert

• Complexity is O(log n), where n is heap size.

48
Removing The Max Element

• Max element is in the root.

49
Removing The Max Element
7
15
6
2
6
9
8
8
7
5
1
7
7

• After max element is removed.

50
Removing The Max Element
7
15
6
2
6
9
8
8
7
5
1
7
7

• Heap with 10 nodes.

Reinsert 8 into the heap.
51
Removing The Max Element
7
15
6
2
6
9
7
5
1
7
7

• Reinsert 8 into the heap.

52
Removing The Max Element
15
7
6
2
6
9
7
5
1
7
7

• Reinsert 8 into the heap.

53
Removing The Max Element
15
7
9
6
2
6
8
7
5
1
7
7

• Reinsert 8 into the heap.

54
Removing The Max Element
15
7
9
6
2
6
8
7
5
1
7
7

• Max element is 15.

55
Removing The Max Element
7
9
6
2
6
8
7
5
1
7
7

• After max element is removed.

56
Removing The Max Element
7
9
6
2
6
8
7
5
1
7
7

• Heap with 9 nodes.

57
Removing The Max Element
7
9
6
2
6
8
5
1

• Reinsert 7.

58
Removing The Max Element
9
7
6
2
6
8
5
1

• Reinsert 7.

59
Removing The Max Element
9
8
7
6
2
6
7
5
1

• Reinsert 7.

60
Complexity Of Remove Max Element

• Complexity is O(log n).