Queues

Lab on Queues with Singly-Linked Lists

Summary

This laboratory provides practice in using a singly-linked list to implement queues. Specifically, class Queue261Implementation1 will implement the Queue261.java interface, using a QueueNode class to store specific queue items.

Acknowledgement

Much of this material is an edited version of Henry M. Walker, Computer Science 2: Principles of Software Engineering, Data Types, and Algorithms, Little, Brown, and Company, 1989, Section 7.2, with programming examples translated from Pascal to Java. This material is used with permission from the copyright holder.

Introduction

One common implementation of a Queue involves a singly-linked list of QueueNodes, for which a QueueNode class has the following basic structure:

package queues;

public class QueueNode <E>
{
   /**
    * Each QueueNode has a data field of type E
    * and a next field to support a singly-linked list
    */
   private E data;
   private QueueNodee<E> next;

   /**
    * The default construtor sets the data and next fields to null
    */
   public QueueNode<E> ()
   {
      data = null;
      next = null;
   }

   /**
    * An alternative constructor has both data and next parameters
    */
   public QueueNode (E origData, QueueNodee<E> origNext)
   {
      data = origData;
      next = origNext;
   }

   // other methods include the usual getters and setters

}

With this QueueNode structure, a Queue261Implementation1 of the Queue261.java class maintains three private fields numberItems, head, and tail. In this design, numberItems is an integer that specifies the number of items in the queue. Also, head and tail are pointers, as shown in the following diagram:

In this structure, head and tail mark the two ends of the queue, inserting items at the tail and deleting them from the head. Here, we view the queue as ordering items from the head to the tail; the head is the first item we will remove, and the tail is the last item. Also, the data field of a QueueNode contains the reference for one item on the queue, and the next field is a reference to the next QueueNode on the list.

The following notes outline some additional implementation details.

• exceptions:

  • check the specifications for Java's Queue interface to identify conditions under which exceptions are to be thrown.

• constructor:

  • numberItems is set to 0
  • head and tail are set to null

• insert:

  • a new QueueNode is created with the specified data and a null next field
  • the next field of the old tail of the queue is updated to reference the new QueueNode
  • the queue's tail field is changed to point to the new QueueNode
  • if the queue previously was null, then the head pointer also will need to be modified to refer to this new QueueNode

• remove:

  • data are retrieved from the head of the queue
  • the head field is updated to the next element on the list
  • if no further elements remain on the queue (so the new queue becomes empty), then tail field also should be changed to null

Steps for this Lab

1. Write class Queue261Implementation that provides a singly-linked-list implementation of the Queue261 interface, including a default constructor and methods add, remove, element, and size.

2. Be sure to test your implementation carefully!

created 29 March 2012 revised 4 April 2012 revised 6 November 2018
For more information, please contact Henry M. Walker at walker@cs.grinnell.edu.