CS 46B - Lecture 17

Pre-class reading

• Worked Example 16.1
• That's in the PDF of the content area, not the printed book

Doubly-Linked List

• Node class
  

  class Node
  {
     public Object data;
     public Node next;
     public Node previous;
  }
  

• LinkedList stores head and tail reference:
  

  public class LinkedList
  {
     private Node first;
     private Node last;
     ...
  }
  

Removing at Head

Singly-Linked:

public class LinkedList
{
   . . .
   public Object removeFirst()
   {
      if (first == null) { throw new NoSuchElementException(); }
      Object element = first.data;
      first = first.next; 
      return element;
   }
   . . .
}

Lecture 17 Clicker Question 1

What do we need to do to make this method work for doubly-linked lists?

1. Nothing—it will work correctly for doubly-linked lists as well
2. Update the previous reference of the initial node after removal
3. Update the last reference of the LinkedList if the last element was removed
4. Something else

Removing at Head

public class LinkedList
{
   . . .
   public Object removeFirst()
   {
      if (first == null) { throw new NoSuchElementException(); }
      Object element = first.data;
      first = first.next; 
      if (first == null) { last = null; } // List is now empty
      else { first.previous = null; }      return element;
   }
   . . .
}

Adding at Head

Singly-linked:

public void addFirst(Object element)
{
   Node newNode = new Node(); 
   newNode.data = element;
   newNode.next = first; 
   first = newNode; 
}

Lecture 17 Clicker Question 2

What do we need to do to make this method work for doubly-linked lists?

1. Nothing—it will work correctly for doubly-linked lists as well
2. Update the previous reference of the second node
3. Update the last reference of the LinkedList if the last element was inserted
4. Both 2 and 3

Adding at Head

public void addFirst(Object element)
{
   Node newNode = new Node(); 
   newNode.data = element;
   newNode.next = first; 
   if (first == null) { last = newNode; }
   else { first.previous = newNode; }
   first = newNode; 
}

Adding at Tail (New)

public void addLast(Object element)
{
   Node newNode = new Node();
   newNode.data = element;   
   newNode.previous = last;
   if (last == null) { first = newNode; }
   else { last.next = newNode; }
   last = newNode;
}

• Mirror image of addFirst
• Swap first and last
• Swap previous and next
• Same with removeLast, getLast

Bidirectional Iterator

• Add previous method
• Returns element after iterator

  LinkedList lst = new LinkedList();
  lst.addLast("A");
  lst.addLast("B");
  lst.addLast("C");
  ListIterator iter = lst.listIterator(); 
     // The iterator is before the first element |ABC
  iter.next(); 
     // Returns “A”; the iterator is after the first element A|BC 
  iter.next(); 
     // Returns “B”; the iterator is after the second element AB|C
  iter.previous(); 
     // Returns “B”; the iterator is after the first element A|BC

Stateful Remove

• remove removes the last element that was returned by next or previous
• This is madness—we must remember whether the iterator has just moved left or right
• It's only an issue with remove—add adds before the iterator
• Why doesn't remove just remove the element before the iterator?
• The designers of the API wanted this to work

  while (iter.hasNext())
     if (iter.next() has some property) iter.remove();

• And the same for backwards iteration

  while (iter.hasPrevious())
     if (iter.previous() has some property) iter.remove();

Moving Backwards

public Object previous()
{
   if (!hasPrevious()) { throw new NoSuchElementException(); }
   isAfterNext = false;
   isAfterPrevious = true;
   Object result = position.data;
   position = position.previous;
   return result;
}

• Note the isAfterNext, isAfterPrevious flags

remove

• Helper method to find out what to remove

  private Node lastPosition()
  {
     if (isAfterNext) { return position; }
     else if (isAfterPrevious) 
     { 
        if (position == null) { return first; }
        else { return position.next; }
     }
     else { throw new IllegalStateException(); }
  }

remove

• Get the position to remove

  Node positionToRemove = lastPosition();

• Adjust the links around it

  positionToRemove.previous.next = positionToRemove.next; 
  positionToRemove.next.previous = positionToRemove.previous;

• Adjust position

  if (isAfterNext) { position = position.previous; }

• Note that the iterator no longer needs a previous reference

Testing the Implementation

• Book doesn't use JUnit
• In JUnit, make a method for each test case

  @Test void testAddLast() 
  {
     LinkedList lst = new LinkedList();
     check("", lst);
     lst.addLast("A"); 
     check("A", lst);
     lst.addLast("B"); 
     check("AB", lst);
  }

• Lots of other cases—see book

Helper method for checking list contents

• Uses public API only

public static void check(String expected, LinkedList actual)
{
   int n = expected.length();
   if (n > 0)
   {
      // Check first and last reference       
      assertEquals(expected.substring(0, 1), actual.getFirst());
      assertEquals(expected.substring(n - 1), actual.getLast());

      // Check next references
      ListIterator iter = actual.listIterator();
      for (int i = 0; i < n; i++)
      {
         assertEquals(true, iter.hasNext());
         assertEquals(expected.substring(i, i + 1), iter.next());
      }
      assertEquals(false, iter.hasNext());

      // Check previous references
      for (int i = n - 1 ; i >= 0; i--)
      {
         assertEquals(true, iter.hasPrevious());
         assertEquals(expected.substring(i, i + 1), iter.previous());
      }
      assertEquals(false, iter.hasPrevious());
   }
   else
   {
      // Check that first and last are null
      try
      {
         actual.getFirst();
         throw new IllegalStateException("first not null");
      }
      catch (NoSuchElementException ex) 
      {
      }

      try
      {
         actual.getLast();
         throw new IllegalStateException("last not null");
      }
      catch (NoSuchElementException ex)
      {
      }                
   }
}