Introduction to Priority Queues

Chapter: Introduction to Priority Queues

The following functions give the basic interface for a Priority Queue.

void insert(T elem) inserts elem into priority queue
T min() returns the minimal element
T removeMin() returns the minimal element and removes it

A simple Priority Queue could be implemented using a linked list sorted in decreasing order.

insert adds an element to the list in proper position.
max returns the first element in the list
removeMax removes the first element.

This method actually works fairly well. The main problem is that the insertion has O(n) run time. It is possible to be more efficient.

A better implementation uses a heap. A heap is actually implemented as an array with some specialized operations, but can be thought of as a complete binary tree, with a special property satisfied at each node. This property says that a node's value is greater than or equal to its parent. A complete binary tree means that each level is full except perhaps the last, which is simply filled left to right as needed. A goal of any operation is to maintain the heap property and the completeness of the (conceptual) binary tree.

You will recall that we went over the heap operations in lecture. Check your remembrances now and be sure you understand why:

void insert(T elem) is O(log n) because it inserts the new element at the leftmost free spot of the bottom layer of the tree (or the first spot of the next layer if the bottom layer is full) and trickles it up to its correct position by swapping pairs of nodes that fail to satisfy the heap property along the path to the root. Of course, we know the maximum length of such a path is $log n$ .
T max() simply returns the element at the top of the heap (stored at subscript 0 of the array) and is clearly O(1).
T removeMax() replaces the root with the rightmost element in the last level. This might break the heap property at the root, and so begins a trickleDown process of swapping a value with the larger of its children down a path from the root until the heap property is universally restored. Again, the maximum length of such a path is $log n$ , and so the removeMax() operation is $O(log n)$ .

The good news for you is that java.util.PriorityQueue has already been programmed for you and implements a priority queue based on a heap. So you don't need to write the code. But you do need to ensure that anything you store in a heap must implement the Comparable interface.

In this file you will find a list of 100 World cities and their popuations. In order to make it possible to enter the cities into a PriorityQueue you will need to create a Comparable class that can store the data.

Make your own or you can fill out my shell.

Exercise 1

population.txt is a list of the 100 most populous world cities arranged alphabetically by the usual English transcription of the name. Your mission is to print out the top 10 cities, in order by population. Write your own program, or you can fill out a shell of my solution. Incidentally, you will want to remove commas from a string otherwise composed of digits. Here is one way you can do that.

The Heap implementation achieves O(log n) insertions and deletions, which is better than what the sorted list could offer. On this basis it is clear that you can build the heap in time O(n log n). (As a matter of fact, the heap can be built in time O(n). For example see wikipedia.) You can create a top ten list from a file of n cities in the same big Oh time it takes to build the heap.

Q. 1: Why is that?

rhyspj@gwu.edu