Status

• Code review in lab today
• A05b... due Friday
• Quiz 07

Last time

• We wrote a singly-linked List
• Today, some variants of 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)

Add method for SortedList (singly-linked)

class SortedList<E extends Comparable<E>> {

  private Node<E> head;
  private int size;
  
  public void add(E item) {
    Node<E> curr = head;
    Node<E> beforeCurr = null;
    //advance curr until null or pointing to first node >= item
    while (curr != null && curr.getData().compareTo(item) < 0) {
      beforeCurr = curr;
      curr = curr.getNext();
    }
    if (beforeCurr == null) {  //or: if (curr == this.head) {
      //adding at head of list
      this.head = new Node<E>(item, this.head);
    }else {
      beforeCurr.setNext(new Node<E>(item, curr));
    }
    this.size++;
  }
  
  //...other methods...
}

List variant: Sentinel node

• (Back to regular List ADT... though works for SortedList too).
• Create a head node that you never delete
• Never show this node outside the class (so all internal 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.
  • Can use getNode's error-checking to prevent removal of sentinel node

List variant: Doubly-linked nodes

public class DLNode<E> {

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

  public DLNode(DLNode<E> prev, E data, DLNode<E> next) {
    this.data = data;
    this.prev = prev;
    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.

DLNode as subclass

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

  private DLNode<E> prev;

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

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

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

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 sentinel node and doubly-linked
• Advantages of both sentinel and tail pointers
• Start with sentinel pointing to itself
• Need to use == to detect sentinel (to avoid infinite loop)

  public String toString() {
    String str = "";
    DLNode<E> curr = this.sentinel.getNext();
    while (curr != this.sentinel) {
      str += curr.getData() + " ";  //crude toString formatting
      curr = curr.getNext();
    }
    return str;
  }

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();
  }
  
  //...nested LinkedListIterator class here...
}

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()
      }
    }
  }

Wouldn't need beforeLast if we had a doubly-linked list.

For next time

• Collections (java.util) APIs
• A05b due on Friday
• Quiz 07 before Monday's class
• A07: List, iterators, and Java Collections API (covered Mon)