Modifying the SinglyLinkedList Code from Class

As an exercise in thinking through LinkedLists, we modified the code from last class to convert it from a singly linked list to a doubly linked list.

We chose to modify the code for the two classes directly. But we could also have, arhuably should have, extended the other class using inheritence. This would allow us to directly reuse some of the common code and clearly express the relationship, "A doubly linked list is a linked list".

But, as it turns out, we wouldn't actually get to reuse as much as we might hope -- and this way matches the end-of-semester exam. It is also good practice for next week's exam.

Modifying the SinglyLinkedList Code From Class: DLinkedListNode

public class DLinkedListNode 
{
  private Comparable data;
  private DLinkedListNode next;
  private DLinkedListNode prev;
  
  public DLinkedListNode()  
  {
    data = null;
    next = null;
    prev = null;
  }  
  
  public DLinkedListNode (Comparable data, DLinkedListNode prev,
                          DLinkedListNode next) 
  {
   this.data = data; 
   this.next  = next;
   this.prev = prev;
  }
  
  public DLinkedListNode (Comparable data)
  {
    this.data = data;
    this.next = null;
    this.prev = null;
  }
  
  public void setNext (DLinkedListNode next)
  {
    this.next = next;
  }
  
  public void setPrev (DLinkedListNode prev)
  {
    this.prev = prev;
  }
  
  public Comparable getData()
  {
    return data;
  }
  
  public DLinkedListNode getNext()
  {
    return next;
  }
  
  public DLinkedListNode getPrev()
  {
    return prev;
  }
}

Modifying the SinglyLinkedListCode from Last Class: DLinkedList

public class DLinkedList
{
  private DLinkedListNode head;
  private DLinkedListNode tail;
  private DLinkedListNode index;
  
  public class DLinkedListException extends Exception
  {
  
    public DLinkedListException (String msg)
    {
      super(msg);
    }
    
  }
  
  public DLinkedList()
  {
    head = tail = index = null;
  }
  
  public void prepend (Comparable data)
  {
    head = new DLinkedListNode (data, null, head);
    
    if (head.getNext() != null)
      head.getNext().setPrev(head);
    
    if (null == tail)
      tail = head;
      
    if (null == index)
      index = head;
  }
  
  public void append (Comparable data)
  {
    if (null == tail)
      head = index = tail = new DLinkedListNode(data);
    else
    {
      tail.setNext (new DLinkedListNode (data,tail,null));
      tail = tail.getNext();
    }
  }
  
  public void resetIndex()
  {
    index = head;
  }
  
  public Comparable getIndex() throws DLinkedListException
  {
    if (null == index)
      throw new DLinkedListException ("Null index in getIndex()");
   
    return index.getData();
  }
  
  public void advanceIndex() throws DLinkedListException
  {
    if ((index == null) || (null == index.getNext()))
      throw new DLinkedListException ("Null index in advanceIndex()");
      
    index = index.getNext();
  }
  
   public void reverseIndex() throws DLinkedListException
   {
     if ( (null == index) || (index == head) )
       throw new DLinkedListException ("Index is null or has no predecessor");
    
     index = index.getPrev(); 
    
   }
  
    public Comparable deleteAtIndex() throws DLinkedListException
    {
    
      Comparable data;
      
      try 
      {       
        data = index.getData();
        reverseIndex();
        // data = index.getNext().getData(); // Ugly, but avoids NPE
        index.setNext(index.getNext().getNext());
        index.getNext().setPrev(index);
      }
      catch (NullPointerException npe)
      {
        throw new DLinkedListException ("index is null; can't delete");
      }
      catch (DLinkedListException lle)
      {
         // No predecessor; first node in list
        head = index.getNext();
        
        if (head != null)
          head.setPrev(null);
      }
      
      // Index was the tail
      if (index.getNext() == null)
      {
        tail = index;
      }           
      
      // Move index to the one after the one we're deleting
      index = index.getNext();   
      
      return data; 
    }

    public Comparable removeNth (int n) // beginning with 0th 
      throws DLinkedListException
    {
      DLinkedListNode index; // Don't destroy user's index
      int count;
      
      if (null == head)
        throw new DLinkedListException ("Can't delete from empty list");
      
      if (n == 0)
      { 
        if (tail == head)
          tail = null;
          
        if (index == head)
          index = null;
                
        head = head.getNext();
        if (head != null)
          head.setPrev (null);
        
      }
      else
      {      
      
        try 
        {        
          for (index=head, count=0; count <= n; count++, index=index.getNext())
          ;
        }
        catch (NullPointerException npe)
        {
           throw new DLinkedListException ("Less than n nodes on removeNth");
        }
      
        if (index == tail)
           throw new DLinkedListException ("Less than n nodes on removeNth");
        
        if (this.index == index)
          this.index = null;
                
        if (tail == index)
          tail = index.getPrev();  // same as tail=tail.getPrev()
         
        
        index.getPrev().setNext(index.getNext());
        
        if (tail != index)
          index.getNext().setPrev(index.getPrev());
    
      
     }
                          
    }
    
 } /* DLinkedList */