Hello,

I'm just learning about recursion and I need some help. I am given a class RLList (a Linked List) and told to re-implement these methods:

public void add(E newEntry);

public boolean add(int newPosition, E newEntry);

public E remove(E item);

public E remove(int position);

public boolean replace(int givenPosition, E newEntry);

public E getEntry(int givenPosition);

public boolean contains(E anEntry);

public void reverse();

public String toString();

If someone could show me how to do a couple of these and give a little explanation on how you implemented the recursion, that would really help.

Below is the RLList code:

public class RLList<E> implements ListInterface<E>{ private Node<E> firstNode; // reference to first node private int length; // number of entries in list public RLList(){ clear(); } // end default constructor public final void clear(){ //any function called in a constructor must be declared final firstNode = null; length = 0; } // end clear private class Node<E>{ // private inner class private E data; // data portion private Node<E> next; // link to next node private Node(E dataPortion){ data = dataPortion; next = null; } // end constructor private Node(E dataPortion, Node<E> nextNode){ data = dataPortion; next = nextNode; } // end constructor } // end Node public void add(E newEntry){ Node<E> newNode = new Node<E>(newEntry); if (isEmpty()) firstNode = newNode; else{ // add to end of nonempty list Node lastNode = getNodeAt(length); lastNode.next = newNode; // make last node reference new node } // end if length++; } // end add public boolean add(int newPosition, E newEntry){ boolean isSuccessful = true; if ((newPosition >= 1) && (newPosition <= length+1)){ Node<E> newNode = new Node<E>(newEntry); if (isEmpty() || (newPosition == 1)){ // case 1 newNode.next = firstNode; firstNode = newNode; } else{ // case 2: newPosition > 1, list is not empty Node<E> nodeBefore = getNodeAt(newPosition-1); Node<E> nodeAfter = nodeBefore.next; newNode.next = nodeAfter; nodeBefore.next = newNode; } // end if length++; } else isSuccessful = false; return isSuccessful; } // end add public E remove(int givenPosition){ E result = null; // return value if (!isEmpty() && (givenPosition >= 1) && (givenPosition <= length)){ if (givenPosition == 1){ // case 1: remove first entry result = firstNode.data; // save entry to be removed firstNode = firstNode.next; } else{ // case 2: givenPosition > 1 Node<E> nodeBefore = getNodeAt(givenPosition-1); Node<E> nodeToRemove = nodeBefore.next; Node<E> nodeAfter = nodeToRemove.next; nodeBefore.next = nodeAfter; // disconnect the node to be removed result = nodeToRemove.data; // save entry to be removed } // end if length--; } // end if return result; // return removed entry, or null // if operation fails } // end remove public E remove(E item){ return item; } public boolean replace(int givenPosition, E newEntry){ boolean isSuccessful = true; if (!isEmpty() && (givenPosition >= 1) && (givenPosition <= length)){ Node<E> desiredNode = getNodeAt(givenPosition); desiredNode.data = newEntry; } else isSuccessful = false; return isSuccessful; } // end replace public E getEntry(int givenPosition){ E result = null; // result to return if (!isEmpty() && (givenPosition >= 1) && (givenPosition <= length)) result = getNodeAt(givenPosition).data; return result; } // end getEntry public boolean contains(E anEntry){ boolean found = false; Node<E> currentNode = firstNode; while (!found && (currentNode != null)){ if (anEntry.equals(currentNode.data)) found = true; else currentNode = currentNode.next; } // end while return found; } // end contains public void reverse(){ } /** Task: Determines whether the list is empty. * @return true if the list is empty, or false if not */ public boolean isEmpty(){ return (firstNode == null); } /** Task: Displays all entries that are in the list, one per * line, in the order in which they occur in the list. */ public void display(){ Node<E> currentNode = firstNode; System.out.print("["); while(currentNode != null){ System.out.print(currentNode.data + " "); currentNode = currentNode.next; } System.out.println("]"); } /** Task: Determines whether the list is full. * @return true if the list is full, or false if not */ public boolean isFull(){ return false; } /** Task: Gets the length of the list. * @return the integer number of entries currently in the list */ public int getLength(){ return length; } /* < Implementations of the public methods add, remove, replace, getEntry, contains, getLength, isEmpty, isFull, and display go here. > */ // ---------------private!----------------------------- /** Task: Returns a reference to the node at a given position. * Precondition: List is not empty; 1 <= givenPosition <= length. */ private Node<E> getNodeAt(int givenPosition){ Node<E> currentNode = firstNode; for (int counter = 1; counter < givenPosition; counter++) currentNode = currentNode.next; return currentNode; } // end getNodeAt } // end LList