The document contains a Java class definition for a sorted linked list, specifically 'ciscsortedlinkedlist', which implements the 'cisclist' interface. The class includes methods for adding, removing, and iterating over elements, along with error handling for null elements and index bounds. Additionally, the author requests assistance with the implementation of the 'add' and 'remove' methods, as they are currently incomplete.

1. Note: Can someone help me with the Public boolean add(E value) method and Private void
add(E value,Node n) method. I have everything but it is not working. Also need help with the
remove methods. Both public and private methods for remove. package edu.ust.cisc; import
java.util.Iterator; import java.util.NoSuchElementException; public class CiscSortedLinkedList
> implements CiscList { /** * A reference to this list's dummy node. Its next reference should
refer to the node containing the first element * in this list, or it should refer to itself if the list is
empty. The next reference within the node containing * the last element in this list should refer to
dummy, thus creating a cyclic list. */ private Node dummy; /** * Number of elements in the list.
*/ private int size; /** * Constructs an empty CiscSortedLinkedList instance with a non-null
dummy node whose next reference refers to * itself. */ public CiscSortedLinkedList() { dummy
= new Node<>(null, null); dummy.next = dummy; } /** * Returns the number of elements in
this list. * * @return the number of elements in this list */ @Override public int size() { return
size; } /** * Returns {@code true} if this list contains no elements. * * @return {@code true} if
this list contains no elements */ @Override public boolean isEmpty() { return size==0; } /** *
Returns {@code true} if this list contains the specified element (compared using the {@code
equals} method). * This implementation should stop searching as soon as it is able to determine
that the specified element is not * present. * @param o element whose presence in this list is to
be tested * @return {@code true} if this list contains the specified element * @throws
NullPointerException if the specified element is null */ @Override public boolean
contains(Object o) { if(o==null){ throw new NullPointerException(); } return
containsHelper(o,dummy.next); } private boolean containsHelper(Object o, Node node){
if(node== dummy){ return false; } else if(o.equals(node.data)){ return true; } else{ return
containsHelper(o,node.next); } } /** * Returns an iterator over the elements in this list in proper
sequence. * * @return an iterator over the elements in this list in proper sequence */ @Override
public Iterator iterator() { //return new Iterator (){ //private Node curr = dummy.next; //private
Node prev = dummy; //private boolean canRemove = false; return new CiscLinkedListIterator();
} /** * Returns an array containing all of the elements in this list in proper sequence (from first
to last element). * *
The returned array will be "safe" in that no references to it are maintained by this list. (In other
words, * this method must allocate a new array even if this list is backed by an array). The caller
is thus free to modify * the returned array. * * @return an array containing all of the elements in
this list in proper sequence */ @Override public Object[] toArray() { Object[] arr = new
Object[size]; int i = 0; for(Node current = dummy;current!=null;current= current.next){ arr[i++]
= current.data; } return arr; } /** * {@link #toArray} recursive helper method. Adds the element
contained in the specified node to the specified index * in the specified array. Recursion stops
when the specified node is the dummy node. * * @param arr the array into which each element
in this list should be added * @param index the index into which the next element in this list
should be added * @param n the node containing the next element in this list to add to the array
*/ private void toArray(Object[] arr, int index, Node n) { } /** * Adds the specified element to
its sorted location in this list. * *
Lists may place the specified element at arbitrary locations if desired. In particular, an ordered
list will * insert the specified element at its sorted location. List classes should clearly specify in
their documentation * how elements will be added to the list if different from the default
behavior (end of this list). * * @param value element to be added to this list * @return {@code

2. true} * @throws NullPointerException if the specified element is null */ @Override public
boolean add(E value) { if(value==null){ throw new NullPointerException(); } Node newNode =
Node(value); return false; } /** * {@link #add} recursive helper method. Adds the specified
value to the list in a new node following the specified * node (if that is the appropriate location
in the list). * * @param value element to be added to this list * @param n a reference to the node
possibly prior to the one created by this method */ private void add(E value, Node n) { } /** *
Removes the first occurrence of the specified element from this list, if it is present. If this list
does not * contain the element, it is unchanged. Returns {@code true} if this list contained the
specified element. This * implementation should stop searching as soon as it is able to determine
that the specified element is not * present. * * @param o element to be removed from this list, if
present * @return {@code true} if this list contained the specified element * @throws
NullPointerException if the specified element is null */ @Override public boolean
remove(Object o) { if(o==null){ throw new NullPointerException(); } Node curr = dummy.next;
Node prev = dummy; while (curr != dummy && !o.equals(curr.data)) { prev = curr; curr =
curr.next; } if (curr == dummy) { return false; } else { System.out.println("Removing
Data:"+curr.data); prev.next = curr.next; size--; return true; } } /** * {@link #remove} recursive
helper method. Removes the node following n if it contains the specified element. This *
implementation should stop searching as soon as it is able to determine that the specified element
is not * present. * * @param o element to be removed from this list, if present * @param n a
reference to the node prior to the one possibly containing the value to remove * @return */
private boolean remove(Object o, Node n) { return false; } /** * Removes all of the elements
from this list. The list will be empty after this call returns. @Override public void clear() {
dummy.next=dummy; size=0; } /** * Returns the element at the specified position in this list. *
* @param index index of the element to return * @return the element at the specified position in
this list * @throws IndexOutOfBoundsException if the index is out of range */ @Override
public E get(int index) { if (index < 0 || index >= size) { throw new
IndexOutOfBoundsException(); } return get(index, 0, dummy.next); //if (index < 0 || index >=
size) { //throw new IndexOutOfBoundsException(); } //return null; /** * {@link #get} recursive
helper method. Returns the element contained within the node parameter whose index * matches
the specified index. * * @param index index of the element to return * @param currentIndex the
index of the node parameter * @param n the node containing the element at currentIndex *
@return the element at the specified position (index) in this list */ private E get(int index, int
currentIndex, Node n){ if (currentIndex == index) { return n.data; } return get(index,
currentIndex + 1, n.next); //return null; } /** * This operation is not supported by
CiscSortedLinkedList. * * @param index index of the element to replace * @param element
element to be stored at the specified position * @return the element previously at the specified
position * @throws UnsupportedOperationException if the {@code set} operation is not
supported by this list */ @Override public E set(int index, E element) { throw new
UnsupportedOperationException(); } /** * This operation is not supported by
CiscSortedLinkedList. * * @param index index at which the specified element is to be inserted *
@param element element to be inserted * @throws UnsupportedOperationException if the
{@code set} operation is not supported by this list */ @Override public void add(int index, E
element) { if(!add(element)){ throw new UnsupportedOperationException(); } } /** * Appends
all elements in the specified list to the end of this list, in the order that they are returned by the *
specified list's iterator. * * @param c list containing elements to be added to this list * @return
{@code true} if this list changed as a result of the call * @throws NullPointerException if the

3. specified list is null */ @Override public boolean addAll(CiscList extends E> c) { if(c==null){
throw new NullPointerException(); } return false; } /** * Removes the element at the specified
position in this list. Shifts any subsequent elements to the left * (subtracts one from their
indices). Returns the element that was removed from the list. * * @param index the index of the
element to be removed * @return the element previously at the specified position * @throws
IndexOutOfBoundsException if the index is out of range */ @Override public E remove(int
index) { if(index<0 || index>size){ throw new IndexOutOfBoundsException(); } return null; }
/** * {@link #remove} recursive helper method. Removes the node following n if it contains the
element at the specified * index. * * @param index the index of the element to be removed *
@param currentIndex the index of the node parameter * @param n the node containing the
element at currentIndex * @return */ private E remove(int index, int currentIndex, Node n) {
return null; } /** * Returns the index of the first occurrence of the specified element in this list,
or -1 if this list does not * contain the element (compared using the {@code equals} method).
This implementation should stop searching as * soon as it is able to determine that the specified
element is not present. * * @param o element to search for * @return the index of the first
occurrence of the specified element in this list, or -1 if this list does not * contain the element *
@throws NullPointerException if the specified element is null */ @Override public int
indexOf(Object o) { if(o==null){ throw new NullPointerException(); } return indexOf(o,0,
dummy.next); } /** * {@link #indexOf} recursive helper method. Returns currentIndex if the
element contained in the node parameter is * equal to the specified element to search for. This
implementation should stop searching as soon as it is able to * determine that the specified
element is not present. * * @param o element to search for * @param currentIndex the index of
the node parameter * @param n the node containing the element at currentIndex * @return the
index of the first occurrence of the specified element in this list, or -1 if this list does not *
contain the element */ private int indexOf(Object o, int currentIndex, Node n) {
if(n.data.equals(o)){ return currentIndex; } else if(n==dummy){ return -1; } else
if(n.data.compareTo((E)o)>0){ return -1; } else{ return indexOf(o,currentIndex+1,n.next); } }
/** * Returns a string representation of this list. This string should consist of a comma separated
list of values * contained in this list, in order, surrounded by square brackets (examples: [3, 6, 7]
and []). * * @return a string representation of this list */ public String toString() { return null; }
/** * {@link #toString} recursive helper method. Returns a string representation of this list,
beginning with the * element in the specified node * * @param n the node containing the next
element to append to the string * @return a string representation of this list, beginning with the
element in the specified node */ private String toString(Node n) { return null; } private static
class Node { private E data; private Node next; private Node(E data, Node next) { this.data =
data; this.next = next; } } private class CiscLinkedListIterator implements Iterator { /** * A
reference to the node containing the next element to return, or to the dummy node if there are no
more * elements to return. */ private Node nextNode; /** * Constructs an iterator ready to return
the first element in the list (if present). */ public CiscLinkedListIterator() {
nextNode=dummy.next; } /** * Returns {@code true} if the iteration has more elements. (In
other words, returns {@code true} if * {@link #next} would return an element rather than
throwing an exception.) * * @return {@code true} if the iteration has more elements */
@Override public boolean hasNext() { return nextNode!=dummy && nextNode!=null; } /** *
Returns the next element in the iteration. * * @return the next element in the iteration * @throws
NoSuchElementException if the iteration has no more elements */ @Override public E next() {

4. if(!hasNext()){ throw new NoSuchElementException(); } E data=nextNode.data;
nextNode=nextNode.next; return data; } } }