Priority Queues

• At last, a new data structure.
• A priority queue is a container
  • It assumes that the data stored has a key value.
    • This has the < or > operator implemented.
    • And is used for comparing the "cost" or priority of the item.
  • $O(\log n)$ for most operations.
    • Insert(i):Insert an item
    • ExtractMin:Extract the item with (minimal, maximal) cost.
  • Like a stack/queue you only have access to one item, the min/max
    • But they do implement this
  • Unlike a stack/queue there is some cost associated with maintaining this structure.
• They first argue that $O(\log n)$ time is reasonable.
  • A sequence of O(n) priority queue operations can be used to sort a set of n values.
    • Consider the following algorithm

    • 
       Let H be a priority queue containing n elements.
       Let A be an array
       While H is not empty
           Extract the minimum element from H and append it to A 
       

  • Since H contains n elements, line 3 will execute exactly n times.
    Thus line 3 is O(n).
    By definition of a priority queue, line 4 is  O(log n )
    Therefore the a set of n values can be sorted in O(n log n) using a priority queue.
             

  • If we wanted, we could also argue that the priority queue can be constructed in $O(n \log n)$ operations.
    • How?
  • Since we have a lower bound on comparison based sorting, we can argue that Insert and Extract Min in a priority queue must be $\Theta(\log n)$
• Priority queues are used
  • In an OS where process have priorities.
  • At Disney where people have priorities in lines.
    • (Well not really, they just have "line jump" privileges)
    • But this is parallel processing
  • Anywhere there is a situation with priorities.
• How can we implment a priority queue?
  • An ordered array/list will not do
    • In order to maintain order, insert will be $O(n)$
  • A non-ordered array/list would require $O(n)$ to find min item.
  • We will use a heap