Status check

• New office: POST 314D
• Quiz 07: in Laulima after all.
  • Just embedded necessary tests in a main method for you to run.
• Quiz 06
  • A class extends Object if nothing else
  • Can put an object into a variable of any of its supertypes
  • abstract classes cannot be instantiated
• Don't use super so much: only when this. won't do
• A06b
  • Trying to transition you to design; you are given the algorithm; trace with coins + sample output; additional pieces given under Advice

Last time

• We wrote a singly-linked List
• Today, some variants on that design:
  • sorted list (different ADT)
  • sentinel node
  • doubly-linked nodes
  • tail pointer
  • circular list
  • array-based nodes

List ADT variant: Sorted list

• Added items need to be Comparable, so:

  public class List<E extends Comparable<E>> {
  

• Change add method so can't add out of order:

  public void add(E item)
  

• (assuming singly-linked)
• Loop through Nodes with curr and beforeCurr variables, comparing item to each curr.getData()
• First item found that is greater or equal: insert just before
  • This might be head of the list (special case)

List variant: Sentinel node

• Create a head node that you never delete
• Never show this node outside the class (so all indices + 1)
• Simplifies add -- only need one case:

    Node<E> before = this.getNode(index - 1); //if sentinel == -1
    Node<E> toAdd = new Node<E>(item, before.getNext());
    before.setNext(toAdd);
    this.size++;
  

• Similarly with remove.

List variant: Doubly-linked nodes

public class DLNode<E> extends Node<E> {

  private E data;
  private DLNode<E> next;
  private DLNode<E> prev;

  public DLNode(E data, DLNode<E> next) {
    this.data = data;
    this.next = next;
  }

  public DLNode(E data) {
    this(data, null);
  }

  public E getData() {
    return data;
  }

  public void setData(E data) {
    this.data = data;
  }

  public DLNode<E> getNext() {
    return next;
  }

  public void setNext(DLNode<E> next) {
    this.next = next;
  }
  
  public DLNode<E> getPrevious() {
    return prev;
  }
  
  public void setPrevious(DLNode<E> prev) {
    this.prev = prev;
  }
}

Alternatively: could have extended Node to just add previous details.

Doubly-linked List

• Add and deleting a bit more complicated
• But can move either direction through list now
• And don't need to find previous node from the one you want to delete (compare)

List variant: tail pointer

• Very common to add to end of a list; makes this O(1) rather than O(n)
• Can come to middle from front or end depending on sought index (if doubly-linked)

List variant: Circular list

• Usually a combination of sentinal node and doubly-linked
• Advantages of both sentinal and tail pointers
• Need to use == to detect sentinel (to avoid infinite loop)

List variant: Array-based linked list

• DL nodes that contain indicies rather than references
• Build an array of DLNodes and manage free space
• Not really necessary in Java
  • but I've had to implement one of these in a language with no dynamic memory allocation

Why we need them

  List<String> list = new List<String>();
  //...add some values...
  for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));  
  }

• What's the big-O? Why?

java.util.Iterator<E> interface

Basically an object that moves along the list

• boolean hasNext()
  -- Returns true if the iteration has more elements.
• E next()
  -- Returns the next element in the iteration (or else java.util.NoSuchElementException)
• void remove() (optional)
  -- Removes from the underlying collection the last element returned by the iterator (optional operation).
  • This method can be called only once per call to next. The behavior of an iterator is unspecified if the underlying collection is modified while the iteration is in progress in any way other than by calling this method.

Our Iterator

• Let's add one to List implementation from last time.
• For efficiency, need access to List implmentation (top, size, Nodes, etc)
• Could just put in the same package and make those protected
• But Iterator class also intimately connected to List class
• Makes sense here to use a nested class (may not have seen this before)
  • Declare one class in another and inner class has access to even private outer class details
  • Full name: OuterClass.InnerClass
  • (one of the few things to make static if you can; here, we can't)

A basic Iterator

public class List<E> {
  //...current contents...

  public class LinkedListIterator implements java.util.Iterator<E> {
    //Note: did not redeclare <E>

    Node<E> next;  //Node of item to return on next call to next()

    public LinkedListIterator() {
      this.next = head;  //refers's to List's head.  Explicit: List.this.head
    }

    public boolean hasNext() {
      return next != null;
    }

    public E next() {
      if (next == null) {
        throw new java.util.NoSuchElementException();
      }else {
        E item = next.getData();
        next = next.getNext();
        return item;
      }
    }

    public void remove() {
      //optional: not implemented here
      throw new UnsupportedOperationException();
    }
  }

}//end of List

How to build a new iterator?

• Need a method in List that returns an iterator
• java.lang.Iterable<E>
  • Iterator<T> iterator()
    --Returns an iterator over a set of elements of type T.
• Also allows use of for-each loop!

Iterable List

class List<E> implements Iterable<E> {
  //...current contents...

  
  public java.util.Iterator<E> iterator() {
    return new LinkedListIterator();  //or: new List<E>.LinkedListIterator();
  }
}

Iterator and Iterable use

  List<Integer> list = new List<Integer>();
  for (int i = 1; i < 10; i++) {
    list.add(i - 1, i);
  }

  //iterator for-each loop  (thanks to List implementing Iterable)
  for (int item : list) {
    System.out.print(item + " ");
  }
  System.out.println();

  //basically equivalent using iterator directly
  int item;
  for (java.util.Iterator<Integer> iter = list.iterator(); iter.hasNext(); ) {
    item = iter.next();
    System.out.print(item + " ");
  }
  System.out.println();

An Iterator with remove() implemented

  public class LinkedListIterator implements java.util.Iterator<E> {

    Node<E> next;  //Node of item to return on next call to next()
    Node<E> last;  //Node of item returned by last call to next()
    Node<E> beforeLast;  //Node before last, needed for remove()

    public LinkedListIterator() {
      this.next = head;  //refers's to List's head.  Explicit: List.this.head
      this.last = null;
      this.beforeLast = null;
    }

    public boolean hasNext() {
      return next != null;
    }

    public E next() {
      if (next == null) {
        throw new java.util.NoSuchElementException();
      }else {
        E item = next.getData();

        //advance along list
        if (last != null) {
          beforeLast = last;
        }
        last = next;
        next = next.getNext();

        return item;
      }
    }

    public void remove() {
      if (this.last == null) {
        //next() not called yet or already removed since call
        throw new IllegalStateException();
      }else {
        if (beforeLast == null) {
          //haven't returned second item of list yet, so removing first
          head = next;
        }else {
          beforeLast.setNext(next);
        }
        last = null;  //so we know we removed since last call to next()
      }
    }
  }

Could use only next and last (or similar) if we had a doubly-linked list.

For next time

• Collections (java.util) APIs
• A06b continues...
• 2nd exam next week...