import java.util.Iterator; import java.util.NoSuchElementException; import lab4.util.List; public class SinglyLinkedList<E> implements List<E> { @SuppressWarnings("hiding") private class SinglyLinkedListIterator<E> implements Iterator<E>{ private Node<E> nextNode; @SuppressWarnings("unchecked") public SinglyLinkedListIterator() { this.nextNode = (Node<E>) header.getNext(); } @Override public boolean hasNext() { return nextNode != null; } @Override public E next() { if (this.hasNext()) { E result = this.nextNode.getElement(); this.nextNode = this.nextNode.getNext(); return result; } else { throw new NoSuchElementException(); } } } private static class Node<E> { private E element; private Node<E> next; public Node(E element, Node<E> next) { super(); this.element = element; this.next = next; } public Node() { super(); } public E getElement() { return element; } public void setElement(E element) { this.element = element; } public Node<E> getNext() { return next; } public void setNext(Node<E> next) { this.next = next; } } private Node<E> header; private int currentSize; public SinglyLinkedList() { this.header = new Node<>(); this.currentSize = 0; } @Override public int size() { return this.currentSize; } @Override public boolean isEmpty() { return this.size() == 0; } @Override public boolean contains(E e) { return this.firstIndexOf(e) >= 0; } @Override public int firstIndexOf(E e) { int i = 0; for (Node<E> temp = this.header.getNext(); temp != null; temp = temp.getNext(), ++i) { if (temp.getElement().equals(e)) { return i; } } // not found return -1; } @Override public void add(E e) { if (this.isEmpty()) { this.header.setNext(new Node<E>(e, null)); this.currentSize++; } else { Node<E>temp= this.header.getNext(); while (temp.getNext() != null) { temp = temp.getNext(); } Node<E> newNode = new Node<>(e, null); temp.setNext(newNode); this.currentSize++; } } @Override public void add(E e, int index) { if ((index < 0) || (index > this.currentSize)) { throw new IndexOutOfBoundsException(); } if (index == this.currentSize) { this.add(e); } else { Node<E> temp = null; if (index == 0) { temp = this.header; } else { temp = this.getPosition(index -1); } Node<E> newNode = new Node<>(); newNode.setElement(e); newNode.setNext(temp.getNext()); temp.setNext(newNode); this.currentSize++; } } @Override public E get(int position) { if ((position < 0) || position >= this.currentSize) { throw new IndexOutOfBoundsException(); } Node<E> temp = this.getPosition(position); return temp.getElement(); } private Node<E> getPosition(int index){ int currentPosition=0; Node<E> temp = this.header.getNext(); while(currentPosition != index) { temp = temp.getNext(); currentPosition++; } return temp; } @Override public boolean remove(int index) { if ((index < 0) || (index >= this.currentSize)){ throw new IndexOutOfBoundsException(); } else { Node<E> temp = this.header; int currentPosition =0; Node<E> target = null; while (currentPosition != index) { temp = temp.getNext(); currentPosit.

1. import java.util.Iterator;
import java.util.NoSuchElementException;
import lab4.util.List;
public class SinglyLinkedList<E> implements List<E> {
@SuppressWarnings("hiding")
private class SinglyLinkedListIterator<E> implements Iterator<E>{
private Node<E> nextNode;
@SuppressWarnings("unchecked")
public SinglyLinkedListIterator() {
this.nextNode = (Node<E>) header.getNext();
}
@Override
public boolean hasNext() {
return nextNode != null;
}
@Override
public E next() {
if (this.hasNext()) {
E result = this.nextNode.getElement();
this.nextNode = this.nextNode.getNext();
return result;
}
else {
throw new NoSuchElementException();
}
}
}
private static class Node<E> {
private E element;
private Node<E> next;
public Node(E element, Node<E> next) {
super();
this.element = element;
this.next = next;
}
public Node() {

2. super();
}
public E getElement() {
return element;
}
public void setElement(E element) {
this.element = element;
}
public Node<E> getNext() {
return next;
}
public void setNext(Node<E> next) {
this.next = next;
}
}
private Node<E> header;
private int currentSize;
public SinglyLinkedList() {
this.header = new Node<>();
this.currentSize = 0;
}
@Override
public int size() {
return this.currentSize;
}
@Override
public boolean isEmpty() {
return this.size() == 0;
}
@Override
public boolean contains(E e) {
return this.firstIndexOf(e) >= 0;
}
@Override
public int firstIndexOf(E e) {
int i = 0;

3. for (Node<E> temp = this.header.getNext(); temp != null;
temp = temp.getNext(), ++i) {
if (temp.getElement().equals(e)) {
return i;
}
}
// not found
return -1;
}
@Override
public void add(E e) {
if (this.isEmpty()) {
this.header.setNext(new Node<E>(e, null));
this.currentSize++;
}
else {
Node<E>temp= this.header.getNext();
while (temp.getNext() != null) {
temp = temp.getNext();
}
Node<E> newNode = new Node<>(e, null);
temp.setNext(newNode);
this.currentSize++;
}
}
@Override
public void add(E e, int index) {
if ((index < 0) || (index > this.currentSize)) {
throw new IndexOutOfBoundsException();
}
if (index == this.currentSize) {
this.add(e);
}
else {
Node<E> temp = null;
if (index == 0) {
temp = this.header;
}
else {
temp = this.getPosition(index -1);
}
Node<E> newNode = new Node<>();
newNode.setElement(e);

4. newNode.setNext(temp.getNext());
temp.setNext(newNode);
this.currentSize++;
}
}
@Override
public E get(int position) {
if ((position < 0) || position >= this.currentSize) {
throw new IndexOutOfBoundsException();
}
Node<E> temp = this.getPosition(position);
return temp.getElement();
}
private Node<E> getPosition(int index){
int currentPosition=0;
Node<E> temp = this.header.getNext();
while(currentPosition != index) {
temp = temp.getNext();
currentPosition++;
}
return temp;
}
@Override
public boolean remove(int index) {
if ((index < 0) || (index >= this.currentSize)){
throw new IndexOutOfBoundsException();
}
else {
Node<E> temp = this.header;
int currentPosition =0;
Node<E> target = null;
while (currentPosition != index) {
temp = temp.getNext();
currentPosition++;
}
target = temp.getNext();
temp.setNext(target.getNext());
target.setElement(null);

5. target.setNext(null);
this.currentSize--;
return true;
}
}
@Override
public E set(int position, E newElement) {
if ((position < 0) || position >= this.currentSize) {
throw new IndexOutOfBoundsException();
}
Node<E> temp = this.getPosition(position);
E result = temp.getElement();
temp.setElement(newElement);
return result;
}
@Override
public void clear() {
while(!this.isEmpty()) {
this.remove(0);
}
}
@Override
public Iterator<E> iterator() {
return new SinglyLinkedListIterator<E>();
}
@Override
public int lastIndexOf(E e) {
int i = 0, result = -1;
for (Node<E> temp = this.header.getNext(); temp != null;
temp = temp.getNext(), ++i) {
if (temp.getElement().equals(e)) {
result = i;
}
}
// not found
return result;
}

6. @Override
public E first() {
return get(0);
}
@Override
public E last() {
return get(size() - 1);
}
@Override
public boolean remove(E e) {
int i = this.firstIndexOf(e);
if (i < 0) {
return false;
}else {
this.remove(i);
return true;
}
}
@Override
public int removeAll(E e) {
int count = 0;
while (this.remove(e)) {
count++;
}
return count;
}
/**
* TODO EXERCISE 1:
* Implement an O(n) member method called reverse()
* which reverses the elements in a list with n elements.
*
* For example, if L = {Ken, Al, Bob, Mel} then a call to L.reverse() turns L into
* L = {Mel, Bob, Al, Ken}.
*
* Note: A call to reverse() modifies the contents of the list L, it does not
* create a copy of L.
*/

7. public void reverse() {
/*TODO ADD YOUR CODE HERE*/
}
}
5. (20 pts) Head over to Hasprefixsumproblem. java after finishing exercise 4. The instructions
for this exercise are as follows: - Implement a method that determines if a LinkedList has an
initial sequence of nodes whose values sum to n. If so, it returns an integer corresponding to how
many elements at the beginning of the list add up to n . - The method receives as parameter a
Node that represents the head node of a singlyLinkedList, as well as an integer n denoting a
target sum to search for. - It is assumed that the List always has at least one node. - All the
elements in the List are assumed to be non-negative integers. - If no sequence of initial elements
adds up to n , the method will return a negative value, which is specified as follows: 1. The
negative of the size of the List if the sum of all elements in the List is less than n . 2. The
negative of the minimum number of elements at the beginning of the List whose sum exceeds n .
Examples (these show the lists as arrays, but you will only be given the head node of each singly
linked list) 1. A call to hasprefixsum ({ 1 , 2 , 3 , 4 , 5 } , 10 ) returns 4 since 1 + 2 + 3 + 4 = 10 ,
which is an exact sum of 10 with the first 4 elements of the list. 2. A call to hasprefixsum ({ 2 , 4
, 6 , 8 , 10 } , 10 ) returns 3 since 2 + 4 + 6 = 12 , which is larger than 10. 3. A call to
hasprefixsum ({ 1 , 2 , 3 , 4 } , 15 ) returns 4 since 1 + 2 + 3 + 4 = 10 , which is smaller than 15
and the list does not have enough elements to sum up to 15