Question

Create a CircularArrayQueue<E> implementation of the Queue<E> interface defined in class.

Hints:

• You will need two index variables to keep track of the start and the end of the queue.
• Consider the queue to be empty when the front/back index pointers are equal (which means that the 'back' pointer will always be pointing at the next place to add an item).
• Be careful of index increments and decrements; make sure you perform the operations necessary to make the pointers loop around to the other side of the array.

Note: one new method appears below which was not discussed in class. The clear method should clear the queue and return nothing.

public interface Queue<E> {

  /**
   * Adds an element to the queue. Return false
   * if the element cannot be added.
   * @param value - the value to add
   * @return - true if the element was added, false otherwise
   */
  public boolean add(E value);

  /**
   * Removes a value from the front of the queue
   * @return - the removed value
   */
  public E remove();

  /**
   * Returns the value at the front of the queue
   * without removing it
   * @return - the value at the front of the queue
   */
  public E peek();

  /**
   * Returns true if this list contains no elements.
   * @return true if this list contains no elements
   */
  public boolean isEmpty();

  /**
   * Clear the queue
   */
  public void clear();

}

Answer 1

Here is the completed code for this problem. Comments are included, go through it, learn how things work and let me know if you have any doubts or if you need anything to change. If you are satisfied with the solution, please rate the answer. Thanks

// CircularArrayQueue.java

public class CircularArrayQueue<E> implements Queue<E> {

      // underlying array

      private E[] queue;

      // index of front and back elements

      private int front, back;

      // for avoiding type cast warnings, we use @SuppressWarnings("unchecked")

      @SuppressWarnings("unchecked")

      public CircularArrayQueue() {

            // creating an array with default capacity 10

            queue = (E[]) new Object[10];

            // setting 0 as front and rear index

            front = back = 0;

      }

      @Override

      public boolean add(E value) {

            // queue is full when (back + 1) % queue.length returns front index

            if ((back + 1) % queue.length == front) {

                  // in that case, doubling queue size

                  resize(queue.length * 2);

            }

            // adding value to index back

            queue[back] = value;

            // updating back index, wrapping around from the beginning if necessary

            back = (back + 1) % queue.length;

            return true;

      }

      @Override

      public E remove() {

            if (isEmpty()) {

                  // empty

                  return null;

            }

            // taking element at front

            E elem = queue[front];

            // updating front index, wrapping around from the beginning if necessary

            front = (front + 1) % queue.length;

            return elem; // returning removed element

      }

      @Override

      public E peek() {

            if (isEmpty()) {

                  // empty

                  return null;

            }

            // element at front index

            return queue[front];

      }

      @Override

      public boolean isEmpty() {

            // returns true if front and back are same

            return front == back;

      }

      @Override

      public void clear() {

            // simply setting front and back to 0

            front = back = 0;

      }

      // private helper method to resize the array when full

      @SuppressWarnings("unchecked")

      private void resize(int newCap) {

            // creating a new array

            E[] newArr = (E[]) new Object[newCap];

            int i = front;

            int index = 0;

            // copying elements from old array to new (loops until i and back are

            // same)

            while (i != back) {

                  newArr[index] = queue[i];

                  i = (i + 1) % queue.length;

                  index++;

            }

            // replacing old array with new, updating front and back indices

            queue = newArr;

            front = 0;

            back = index;

      }

}