Fill in the remaining methods in the below code

 

package DataStructures; import ADTs.ListADT; import Exceptions.ElementNotFoundException; import Exceptions.EmptyCollectionException; import Exceptions.InvalidArgumentException; /** * * @param  * @version 1.0 */ public class CircularDoublyLinkedList> implements ListADT { private DoublyLinkedNode first; private int numNodes; /** * Constructor. */ public CircularDoublyLinkedList() { first = null; numNodes = 0; } /** * Retrieve the first element in the circular list, * which is stored in the current first node * @return first element */ @Override public T first() throws EmptyCollectionException{ if (first == null) throw new EmptyCollectionException("CircularDoublyLinkedList"); return first.getElement(); } /** * retrieve the element of the current first node in the list * @return */ public T current(){ if (first == null) return null; return first.getElement(); } /** * Retrieve the last element in the list, * which next reference points to the current first node * @return * @throws EmptyCollectionException */ @Override public T last() throws EmptyCollectionException{ if (first == null) throw new EmptyCollectionException("CircularDoublyLinkedList"); return first.getPrev().getElement(); } @Override /** * Examine whether the circular list is empty. */ public boolean isEmpty() { return (first == null); } /** * Print all elements in the list. */ public void printList() { // Is list empty? if(first == null) return; // start at the head and print everyone boolean startFlag = true; for(DoublyLinkedNode tmp=first; (tmp != first) || startFlag; tmp=tmp.getNext()) { System.out.println(tmp.getElement().toString()); startFlag = false; } } /** * Add a new element in the end of the circular list, * which next reference points to the current first node. * @param element */ @Override public void addLast(T element) { //TODO create the new node //TODO adjust references for new node //TODO increase the numNodes variable } /** * Add a new element in the beginning of the circular list, * which is represented as the current first node. */ @Override public void addFirst(T element) { // create the new node addLast(element); //TODO adjust the current first node reference } /** * Insert a new node which holds the reference to the given element, * after the node which holds the given existing. * Namely insert the given element after the existing element in the list If the given existing is not found, throw an ElementNotFoundException. Note: the CircularDoublyLinkedList class uses the data member variable first and numNodes to maintain the status of a CircularDoublyLinkedList instance. When the method addAfter is invoked, we need to make sure that the data member variable first, and numNodes are changed properly. Do we need to change the data member variable first? And when? * @param existing * @param element * @throws ElementNotFoundException * @throws EmptyCollectionException */ @Override public void addAfter(T existing, T element) throws ElementNotFoundException, EmptyCollectionException { DoublyLinkedNode foundNode = find(existing); //TODO create a node and maintain all references to //insert the new node after the found node. } /** * Remove a node that holds the given element. * @param element * @return * @throws EmptyCollectionException * @throws ElementNotFoundException */ @Override public T remove(T element) throws EmptyCollectionException, ElementNotFoundException { DoublyLinkedNode foundNode = find(element); //TODO remove the found node and maintain all //references, including the current first node reference } /** * Remove the first node in the list. * (prior to the current first node) * @return * @throws EmptyCollectionException */ @Override public T removeFirst() throws EmptyCollectionException { // case 1: empty list if(first == null) throw new EmptyCollectionException("CircularDoublyLinkedList"); DoublyLinkedNode tmp = first; if (this.numNodes == 1){ //case 2 first.setNext(null); first.setPrev(null); first = null; } else { //case 3 first.getPrev().setNext(first.getNext()); first.getNext().setPrev(first.getPrev()); first = tmp.getNext(); } numNodes--; // return a pointer to the removed node return tmp.getElement(); } /** * Remove the last node in the list. * (prior to the current first node) * @return * @throws EmptyCollectionException */ @Override public T removeLast() throws EmptyCollectionException { // TODO remove last node and maintain all references // including the current first node reference. //case 1: empty list // return a pointer to the removed node return tmp.getElement(); } /** * Examine whether the list includes the given element. * @param element * @return * @throws EmptyCollectionException */ @Override public boolean contains(T element) throws EmptyCollectionException { //TODO refer to the printList method } /** * Find the first node which holds the given element. * @param element * @return * @throws EmptyCollectionException */ public DoublyLinkedNode find(T element) throws ElementNotFoundException, EmptyCollectionException { if (numNodes == 0) throw new EmptyCollectionException("CircularDoublyLinkedList"); // walk through the list and find the given element in the list boolean startFlag = true; for(DoublyLinkedNode tmp=first; (tmp != first) || startFlag; tmp=tmp.getNext()) { startFlag = false; if (element.compareTo(tmp.getElement()) == 0) return tmp; } throw new ElementNotFoundException("CircularDoublyLinkedList"); } /** * Retrieve the node at the given index of the list. * @param index * @return * @throws EmptyCollectionException * @throws InvalidArgumentException */ public DoublyLinkedNode getNode(int index) throws EmptyCollectionException, InvalidArgumentException { if (numNodes == 0) throw new EmptyCollectionException("CircularDoublyLinkedList"); if (index < 0 || index >= numNodes) throw new InvalidArgumentException("CircularDoublyLinkedList"); // TODO walk through the list till the given index DoublyLinkedNode tmp=first; for (int count = 0; count < index; count++) tmp=tmp.getNext(); return tmp; } /** * Change the current first node reference to its next node. */ public void next() { if(this.first != null) first = first.getNext(); } /** * Retrieve the element at the given index of the list. * @param index * @return * @throws EmptyCollectionException * @throws InvalidArgumentException */ @Override public T get(int index) throws EmptyCollectionException, InvalidArgumentException { DoublyLinkedNode tmp = getNode(index); return tmp.getElement(); } /** * Reset the element in the given index of the list. * @param index * @param element * @throws EmptyCollectionException * @throws InvalidArgumentException */ @Override public void set(int index, T element) throws EmptyCollectionException, InvalidArgumentException { DoublyLinkedNode tmp = getNode(index); tmp.setElement(element); } /** * Return the total number of elements in the list. * @return */ @Override public int size() { return this.numNodes; } } 

Answer rating: 100% (QA)

Here is the completed version of the CircularDoublyLinkedList class in Java Ive added the necessary implementations for the pending methods java package DataStructures import ADTsListADT import Except... View the full answer