Question

2. In Ex 19 of ME2 we used a DList<E list to store the values of the stack, so we can say that our stack is really just a spe cific type of linked list where we always add and remove elements from only one end of the list. For this exercise, we wish to implement a generic queue data structure, which will also use an underlying linked list to store the data in the queue. Our Queue<E class must implement this public interface: (1) A default ctor which initializes the Queue object being constructed. Recall that ctors initialize the object by initializing some or all of the data members of the object. If the object has no data members to initialize, then the ctor can consist of just an empty body (2) tenqeuelpData E:QueneEwhich adds the value pData to the queue. This method must return the Queue ob- ject. Doing so permits us to chain together multiple enqueue) method calls, e.g., Queue<String> queue- new Queue<>0: queue.enqueue("Wilma").enqueue ("Pebbles").enqueue("Betty"); After adding the strings to the queue, "Wilma" would be at the front of the queue and "Betty" would be at the rear (3) dequeued: E which removes and returns the value which is at the front of the queue. In this code, we shall not con cern ourselves with runtime exceptions which may occur when we attempt to remove data from an empty queue. We assume that the user will not call peek) or dequeue) on an empty queue. (4) peekE which returns the data at the front of the queue, without removing it. As with dequeue), we shall assume the user never calls peek) on an empty queue We may also choose to write other private helper methods as required. Which Queue<E class below is correct? a. public class Queue<E> private DListE mList; public Queue() { DList<E> mList new DList<>(); } public Queue<E enqueue (E pData) mList.append (pData); return this; h public Edequeue() { Evalue mList.remove (0); return value; } public E peekO E value mList.get (o); return value; b. public class Queue<E private DList<E mList; public Queue) setList (new DList<>O) protected int index0fFront ) return 0;) protected int index0fRear) f return getList).getSize) - 1; h public Queue<E enqueue (E pData) getList ).set (indexOfFront), pData); return this; h public E dequeue) E value-getList .remove(index0fRear)) return value; h public E peek) E valuegetList ).get(indexOfFront )); return value;h private DList<E> getListO return mList; h private void setList (DList<E> pList) mList pList; H C. public class Queue<E> extends DListcE> public Queue)h public Queue<E enqueue (E pData) t prepend (pData); return thish public E dequeue) return remove (indexOfFront)) h public E peek ) return get (indexOf Front ); h private int indexOfFrontO return getSize O d. public class Queue<E extends DList<E> public Queue)h public QueueE enqueue (E pData) append (pData); return this; h public E dequeue return remove(indexOfFront)); public E peek ) return get (indexOf Front ); h private int indexOfFrontO return 0; h

e. public class Queue { // Uses the correct Stack class from ME2 Ex 19 private Stack mStack; public Queue() { setStack(new Stack()); } public Queue enqueue(E pData) { getStack().push(pData); return this; } public E dequeue() { return getStack().pop(); } public E peek() { return getStack.peek(); } private Stack getStack() { return mStack; } private void setStack(Stack pStack) { mStack = pStack; } }

f. public class Queue extends Stack { // Uses the correct Stack class from ME2 Ex 19 public Queue() { super(); } public Queue enqueue(E pData) { push(pData); return this; } public E dequeue() { return pop(); } public E peek() { return peek(); } }

Answer 1

Implementation of Option B is the correct one.

DList.java

import java.util.LinkedList;

public class DList<E> {
    //intialize the list
    LinkedList<E> list = new LinkedList<>();

    //get the size of the list
    public int getSize(){
        return list.size();
    }

    //remove the elment from the list
    public E remove(int index){
        return list.remove(index);
    }

    //set the element at index
    public void set(int index, E value){
        list.set(index,value);
    }

    //get the elemnt from the index
    public E get(int index){
        return list.get(index);
    }
}

Queue.java

public class Queue<E> {
    private DList<E> mList;

    public Queue(){
        setList(new DList<>());
    }

    protected int indexOfFromt(){
        return 0;
    }

    protected int indexOfRear(){
        return getList().getSize() - 1;
    }

    public Queue<E> enqueue(E pData){
        getList().set(indexOfFromt(),pData);
        return this;
    }

    public E dequeue(){
        E value = getList().remove(indexOfRear());
        return value;
    }

    public E peek(){
        E value = getList().get(indexOfFromt());
        return value;
    }

    private DList<E> getList(){
        return mList;
    }

    private void setList(DList<E> pList){
        mList = pList;
    }
}