Outline

• queues
• queue interface
• queue implementation: array queue
• using queues
• queue implementation: linked queues
• queue exercises

queues

• a stack is a Last-In, First-Out (LIFO) data structure
• a First-In, First-Out (FIFO) data structure is known as a queue
• the word "queue" is used in the UK for what in the US is known as a "line", e.g. at a supermarket or a bank or a movie theater
• the first person in the queue will be the first one served
• queues are commonly used with computers:
  • documents to be printed are queued
  • packets to be sent on a network are queued
• priority queues allow high-priority items to move to the head of a line, so are not strictly FIFO, whereas
• regular queues are strictly FIFO

queue interface

• a queue is a collection of elements: Interface Queue<E>
• boolean isEmpty()
• boolean offer(E value) attempts to insert the value at the end of the queue, returning whether the insertion was completed
• E poll() removes and returns the object at the head of the queue, or null if the queue is empty
• void remove() is similar to poll, but throws an exception if the queue is empty
• E peek() is similar to poll, but does not remove the element
• Iterator<E> iterator() returns a new iterator over the elements of the queue
• isEmpty() and iterator() are inherited from Interface Collection<E>

queue implementation strategies

• similar to stack
• linked list implementation, or
• array implementation
• as for other collections, we don't need to know the type of the elements, only that they are objects, so a generic implementation is fine

array implementation of queues

• like stack: store all the elements in an array
• when inserting a new element (offer), just like stack, add the element at the end of the queue
• two choices when removing an new element from the front of the list (poll, remove):
  1. copy all subsequent elements down by one index, so the first element is still at the beginning of the array, or
  2. keep track of where the head of the queue is, with another index variable
• for example, removing the front element (a) from this queue:
• can be done by copying:
• or by keeping track of where the first element is:
• in-class exercise: what are the advantages and disadvantages of these two strategies?

in-place array implementation

• two integer variables, one the index of the head of the queue (front), the other the index of the tail of the queue (end)
• so valid elements are found from array[front] through array[end - 1]
• queue contents get ever higher in the array, while lower-numbered indices will no longer contain valid data
• eventually, even if the queue only has a few values, we run out of indices to put new data into
• solution: once we reach the end of the array, put the data beginning at index 0 again
• the modulo operation can be used to make this simple:

  index = (index + 1) % QUEUE_SIZE;
  

• for example, if queue size is 15 and index = 14,
  14 + 1 = 15,
  15 % 15 = 0
  so the new value of the index is 0
• the number of elements in the array is
  (end - front + QUEUE_SIZE) % QUEUE_SIZE,
  but it is easier to simply maintain a size field
• this is an example of adding elements 's' and 't' to a queue:

generic array allocation

• creating a node to hold a reference to an object of type T is easy
• creating an array to hold many reference to objects of type T cannot be done safely in Java
• instead, have to declare:

  private T array[] = (T[])new Object[MAX_SIZE];
  

  and the compiler gives a warning
• this is one of the (few) cases where the warning can be ignored

implementation of the method offer

• if no room, return false or (in textbook, p. 322), double the size of the array
• otherwise,
  • increment the size
  • increment rear modulo capacity
  • insert at rear
• offer may call the private method reallocate if more space is needed
• what is the runtime of this method?

implementation of the method poll

• if there is at least one element,
  • element is taken from front
  • increment front modulo capacity
  • decrement size
  • return element
• if no element, simply returns null
• peek is even simpler, no increment, no size change
• what is the runtime of this method?
• what is the runtime of the empty method?

queue applications

• simulating waiting lines:
  • random arrivals
  • random time to serve a client
  • single queue? multiple queues?
  • compute the average waiting time over many simulations
  • compute the worst case waiting time over many simulations
  • compute the average worst case waiting time for each simulation
• recognizing palindromes:
  • level, racecar, radar, hannah, akasaka
  • queue is FIFO, stack is LIFO
  • push each character onto the stack, offer each character to the queue
  • then remove one character at a time from both data structures
  • the characters should be the same
• in-class exercise (everyone together): do this for racecar, levels

queue implementation strategies reminder

• similar to stack
• linked list implementation
• array implementation
• as always, we don't need to know the type of the elements, only that they are objects

naive linked list implementation of queues

• like stack: store all the elements in a linked list
• can keep two node references, to the first and to the last node in the list
• when the list is empty, these two references will be null
• when the list has one node, these two references will be to the same node
• at other times, these two references point to different nodes

linked list implementation of queues

• these many conditions (0, 1, or multiple nodes) make coding more difficult, and make it easier to make mistakes
• instead, have a single pointer, to the last node of the queue
• in a linked list, this node would have a next field with a value null
• for our queue, instead, this next field can point to the first node of the queue
• now, only two conditions: empty or non-empty queue
• in-class exercise: draw a linked queue with five nodes
• implementation is at LinkedQueue.java

runtime and space

• in-class exercise: what is the runtime for offer()?
• in-class exercise: what is the runtime for poll()?
• in-class exercise: what is the runtime for isEmpty()?
• in-class exercise: how much space does LinkedQueue use?

actual runtime

• run LinkedQueueSpeed.java.html to find out what the actual run-time is
• example runtimes
• in-class discussion: are you surprised?

implementation comparison

• array queue has limited size, or requires reallocating arrays (and copying the data correctly)
• linked queue has flexible size, proportional to the number of items in the queue
• both are O(1) for each operation, or amortized O(1) for offer on the resizable array queue
• the O() runtime may not give us all the information we would like -- actual testing can be followed by profiling, where we find out where in our program we are spending time