Lecture 13 Handout

Learning Outcomes

At the end of this lecture, you’ll be able to:

• Explain and trace the core operations of Queue (enqueue, dequeue, front, empty).
• Describe the difference between enqueue and dequeue.
• Implement the core operations of Queue efficiently (array based and linked base).
• Explain why an efficient linked implementation of Queue requires a tail pointer.
• Explain why an efficient array based implementation of Queue can logically be viewed as a circular data structure.
• Define Steque, Quack, and Deque ADT.

A queue ADT supports two main operations:

• enqueue which adds an element to the data structure
• dequeue which removes the least recently added element that was not yet removed

The order in which elements are removed gives rise to the term FIFO (first in, first out) to describe a queue.

It helps to visualize a queue as an ADT where elements are removed from the front but added to the back, analogously to when people line up to wait for goods or services.

A queue has a variety of applications such as:

• Serving requests on a shared resource, like a printer, CPU, etc.
• Any application that follows a “first come, first served” policy, e.g. customer-service, call-center/ticketing system, etc.
• Whenever it is necessary to preserve sequencing order

Here is the Queue interface which we use in this course:

/**
 * Queue ADT.
 *
 * @param <T> base type.
 */
public interface Queue<T> {

  /**
   * Adds a new element to the back of this queue.
   *
   * @param value to be added
   */
  void enqueue(T value);

  /**
   * Removes the element at the front of this queue.
   *
   * @throws EmptyException when empty() == true.
   */
  void dequeue() throws EmptyException;

  /**
   * Peeks at the front value without removing it.
   *
   * @return the value at the front of this queue.
   * @throws EmptyException when empty() == true.
   */
  T front() throws EmptyException;

  /**
   * Checks if empty.
   *
   * @return true if this queue is empty and false otherwise.
   */
  boolean empty();
}

Make note of enqueue and dequeue: one adds the other removes. Also, there is a front which allows you to peek at the front of the queue without removing the front element.

A singly linked list can be used to implement the Queue ADT efficiently as long as it has a tail pointer (as well as the head pointer). The tail pointer is a reference variable pointing to the other end (opposite of head) of the queue.

Exercise Think about how to implement a queue using a singly linked list such that the core operations are constant time.

Think about a linked implementation of queue such that the core operations are constant time.

Exercise Complete the table below: update the linked list as you trace the operations; show value returned if any.

Exercise Open the starter code and complete the implementation of LinkedQueue. (Do this at home!)

We want to implement the Queue interface using an array as an internal data storage.

Exercise Think about how to implement a queue using an array such that the core operations are constant time. Assume the array is sufficiently large.

Solution

Initialize two variables front and back to zero. When you equeue, add to the back. Use the back variable to index into the array. Then increment it. When you are asked for front element, simply return arr[front]. When you dequeue, simply increment front.

Since you remove from the “front” of the array, then there will be empty positions at the front. So, when the back variable reached the end of the array, it can wrap around it and write to the (actual) “front” of the array, to positions that were removed earlier.

This gives rise to a logical view of array being a circular data structure.

You can also dynamically grow the array when back reaches front.

Operation	How?	Time
enqueue	data[back] = value and back = ++back % length	$O(1)$
dequeue	front = ++front % length	$O(1)$
front	return arr[front]	$O(1)$
empty	check if numElement == 0	$O(1)$

The % length is a trick we use to reset the index when it reaches the length of the array. We could rewrite it as

font = front + 1;
if (front == length) {
  front = 0;
}

The example above replaces front = ++front % length. The same idea can be applied to updating back variable.

Think about an array based implementation of queue such that the core operations are constant time.

Exercise Complete the table below: update the array values at indices 0, 1, 2, 3, and 4 as you trace the operations; show value returned if any.

Exercise Open the starter code and complete the implementation of ArrayQueue.

Notice the constructor of ArrayQueue does not take in a parameter for the size of the array. Feel free to initialize an array with an arbitrarily chosen capacity.

We can mix and match the operations of Stack and Queue to build up new data structures! Here are a few that you may come by in various references.

// A stack-ended queue.
public interface Steque<T> {
  // is empty?
  boolean empty();

  // adds a new element to top of Steque.
  void push(T value);

  // removes and returns top element.
  T pop() throws EmptyException;

  // adds a new element to bottom of Steque.
  void enqueue(T value);
}

steque.push(1);     // [1]
steque.push(2);     // [2, 1]
steque.enqueue(3);  // [2, 1, 3]
steque.enqueue(4);  // [2, 1, 3, 4]
steque.pop();       // [1, 3, 4]

// A queue-ended stack.
public interface Quack<T> {
  // is empty?
  boolean empty();

  // adds a new element to the top of Quack.
  void push(T value);

  // removes and returns top element.
  T pop() throws EmptyException;

  // removes and returns bottom element.
  T dequeue() throws EmptyException;;
}

quack.push(1);   // [1]
quack.push(2);   // [2, 1]
quack.push(3);   // [3, 2, 1]
quack.push(4);   // [4, 3, 2, 1]
quack.pop();     // [3, 2, 1]
quack.dequeue(); // [3, 2]

Deque ADT

Double Ended Queue (Deque) is a limited access data structure that allow insertion/removal at either end in $O(1)$.

• Deque is a stack if you always add/remove at one end.
• Deque is a queue if you always add to one end and remove from other.

Here is an example interface:

// A double-ended queue.
public interface Deque<T> {
    boolean empty();
    T front() throws EmptyException;
    T back() throws EmptyException;
    void insertFront(T t);
    void insertBack(T t);
    void removeFront() throws EmptyException;
    void removeBack() throws EmptyException;
}

The data structures above are not as widely uses as Stack and Queue (especially the first two). We leave it to you as an (unsolved) exercise to implement their operations.