Class 41: Queues and Their Implementation

Held: Friday, 11 November 2005

Summary: Today we consider another important linear structure, the queue. Queues implement a first-in, first-out policy.

Related Pages:

• EBoard.
• Sample Code.

Due

• Exam 2: Objects, Structures, and Algorithms

Notes:

• I will be away on Monday, reviewing grant proposals for NSF. Eryn will run lab on Monday.
• The governmental wording on my charge from NSF suggests that, although I'm supposed to finish on Monday, I may not. If I'm not here on Tuesday, enjoy the day off.

Overview:

• Queues basics.
• An array-based implementation.
• Implementing queues with nodes.
• Priority queues.

Queue Basics

• A queue is a linear structure.
• Queues implement the FIFO (first in, first out) policy
• Queues model lines at a store (among other things).
• Queues are significantly fairer than stacks (most things eventually come out of queues; the first thing added to a stack may never return)
• Historically, the put method in queues is called enqueue and the get method is called dequeue. The peek method is called front.

Implementing queues with arrays

• One strategy for implementing queues is with an array.
• For put, the strategy is similar to that of stacks: Shove it on the end. (We'll need to keep track of the end.)
• At initial glance, get can be fairly simple: Keep track of the index of the first non-returned element (and increment it after each call to get.
• The problem: What happens when we reach the end of the array.
• One strategy: Wrap around.
• The problem: Doing it correctly.
• Arguably, we should be able to get and put in O(1) time.

Implementing queues with nodes

• How can we do better?
• We can use an idea from Scheme.
• Rather than shoving stuff in an array, we use a linked collection of nodes.
• Each node keeps track of
  • The current value (value)
  • A link to the rest of the queue (next)
• Pictorially (at least ASCII-pictorially)

  +---+---+
  | * | *---> N
  +-|-+---+
    V
  

• We'll write a slash for "no next node".
• The queue keeps track of the first node and the last node. (The front and back of the queue.)
• Pictorially,

   FRONT                            BACK
  +---+---+   +---+---+           +---+---+
  |   | *---> |   | *---> ... --> |   | / |
  +---+---+   +---+---+           +---+---+
  

Adding values

• How do we add something to the end of a queue? If we've already created the queue, we want to go from

   FRONT                            BACK
  +---+---+   +---+---+           +---+---+
  |   | *---> |   | *---> ... --> |   | / |
  +---+---+   +---+---+           +---+---+
  

  to

   FRONT                                        BACK
  +---+---+   +---+---+           +---+---+   +---+---+
  |   | *---> |   | *---> ... --> |   | *---> | * | / |
  +---+---+   +---+---+           +---+---+   +-|-+---+
                                              newval
  

• As the picture suggests, we must do three things
  • Create the new node
  • Update the next reference from the old back
  • Make back name the new node
• Problem: What if the queue is empty?

Getting Values

• For non-empty queues, get should be fairly simple.
• We start with

   FRONT                            BACK
  +---+---+   +---+---+           +---+---+
  | * | *---> |   | *---> ... --> |   | / |
  +-|-+---+   +---+---+           +---+---+
   val
  

• We need to save val so that we can return it.
• We want to end up with

                FRONT               BACK
  +---+---+   +---+---+           +---+---+
  | * | / |   |   | *---> ... --> |   | / |
  +-|-+---+   +---+---+           +---+---+
   val
  

• So we need to change the next link of the first node and change what front refers to.
• What special cases do we need to worry about?

Priority Queues

• Our final linear structure is the priority queue.
• Priority queues implement a "highest priority first" get method.
• How do we determine priority?
  • If all the objects in our priority queue are Comparable, we can use the CompareTo method.
  • We can require that each priority queue have an underlying Comparator, which is probably specified in the constructor
• We'll look at implementation issues in the next class.