Question

In Java

You may add any classes or methods to the following as you see fit in order to complete the given tasks.

1. Modify the LinkedList (or DoubleLinkedList) class and add a method append. append should take another LinkedList (DoubleLinkedList) as input and append that list to the end of this list. The append method should work by doing a few "arrow" adjustments on the boxes and it should not loop through the input list to add elements one at a time.

This is the LinkedList class

import java.util.NoSuchElementException;
import java.util.Iterator;

/**
* A class to represent a linked list of nodes.
*/
public class LinkedList<T> implements Iterable<T> {
/** the first node of the list, or null if the list is empty */
private LLNode<T> firstNode;
  
/**
* Creates an initially empty linked list
*/
public LinkedList() {
firstNode = null;
}
  
/**
* Returns the first node.
*/
protected LLNode<T> getFirst() {
return firstNode;
}

/**
* Changes the first node.
* @param node the first node of the new linked list
*/
protected void setFirst(LLNode<T> node) {
this.firstNode = node;
}

/**
* Add an element to the front of the linked list
* @param element the element to add
*/
public void addToFront(T element) {
setFirst(new LLNode<T>(element, getFirst()));
}
  
/**
* Return whether the list is empty
* @return true if the list is empty
*/
public boolean isEmpty() {
return (getFirst() == null);
}
  
/**
* Returns the length of the linked list
* @return the number of nodes in the list
*/
public int length() {
int count = 0; // counts number of nodes seen
LLNode<T> nodeptr = getFirst();
while (nodeptr != null) {
count++;
nodeptr = nodeptr.getNext();
}
return count;
}
  
/**
* Remove and return the element at the front of the list
* @return the first element of the list
* @throws NoSuchElementException if there is no such element
*/
public T removeFromFront() {
if (isEmpty())
throw new NoSuchElementException();
else {
T save = getFirst().getElement();
setFirst(getFirst().getNext());
return save;
}
}

/**
* Add an element to the very end of the list
* @param element the element to add to the end of the list
*/
public void addToEnd(T element) {
if (isEmpty())
addToFront(element);
else {
LLNode<T> nodeptr = getFirst();
// the loop will end with nodeptr looking at the last node in list
while (nodeptr.getNext() != null)
nodeptr = nodeptr.getNext();
nodeptr.setNext(new LLNode<T>(element, null));
}
}
  
/**
* Print the contents of the list to the console.
* @param list the list to print
*/
public static <T> void printList1(LinkedList<T> list) {
LLNode<T> nodeptr = list.getFirst();
while (nodeptr != null) {
System.out.print(nodeptr.getElement().toString() + " ");
nodeptr = nodeptr.getNext();
}
System.out.println();
}
  
/**
* Print the contents of the list to the console.
* @param list the list to print
*/
public static <T> void printList2(LinkedList<T> list) {
// this loop is using the iterator instead of the nodes directly
Iterator<T> it = list.iterator();
while (it.hasNext())
System.out.print(it.next().toString() + " ");
System.out.println();
}
  
/**
* Returns an iterator that will run through the linked list contents in order
* @return the iterator for this linked list
*/
public Iterator<T> iterator() {
return new LinkedListIterator<T>(this.getFirst());
}
}

Answer 1

Added the method

public void append(LinkedList<T> list) {

if (list.isEmpty()) {

return;

} else if (isEmpty()) {

this.setFirst(list.getFirst());

}else {

LLNode<T> nodeptr = getFirst();

// the loop will end with nodeptr looking at the last node in list

while (nodeptr.getNext() != null)

nodeptr = nodeptr.getNext();

nodeptr.setNext(list.getFirst());

}

}


======================================================================
SEE CODE, Dont WORRY About compiler warnings




Thanks, PLEASE COMMENT if there is any concern,

public void append(LinkedList<T> list) 940 95 96 97 if (list.isEmptyO) t else if (isEmptyO) f else ł return; 98 this.setFirst(list.getFirstO); LLNode<T> nodeptr- getFirst); /7 the loop will end with nodeptr looking at the last node in list while (nodeptr.getNext() != null) 3100 101 102 103 104 0105 106 107 108 109 nodeptr-nodeptr.getNext); nodeptr.setNext(list.getFirstO);