package Homework;
//----------------------------------------------------------------------------
// RefUnsortedList.java          by Dale/Joyce/Weems                 Chapter 6
//
// Implements the UnsortedListInterface using references (a linked list).
//----------------------------------------------------------------------------



public class RefUnsortedList extends RefList implements UnsortedListInterface  
{

  public RefUnsortedList() 
  {
    super();
  }

  public void add(Object element)
  // Adds element to this list.
  {
    LLObjectNode newNode = new LLObjectNode(element);
    newNode.setLink(list);
    list = newNode;
    numElements++;
  }
  
  public int removeAll( Object element )
  {
      if (numElements == 0)
      {
          System.out.println ("Cannot delete from an empty list.");
      }
      
      else
      {
          while( numElements > 0  )
          {
              list = null;
              numElements--;
              reset();
          }
      }
      return numElements;
  }
  
  public void endInsert( Object element )
  {
      LLObjectNode newNode = new LLObjectNode( element );
  
      while( list != null)
      {
          list = previous;
      }
      newNode.setLink( list );
      list = newNode;
      numElements++;
  }
}

package Homework;

//-------------------------------------------------------------------------
// RefList.java            by Dale/Joyce/Weems                    Chapter 6
//
// Defines constructs for an unbounded reference-based list of objects that
// do not depend on whether the list is unsorted or sorted.
//
// Our intention is for this class to be extended by classes that furnish
// the remaining methods needed to support a list - for example, a method
// that allows objects to be added to the list.
//
// Null elements are not permitted on a list.
//
// One constructor is provided, one that creates an empty list.
//------------------------------------------------------------------------





public class RefList
{
  protected int numElements;          // number of elements in this list
  protected LLObjectNode currentPos;  // current position for iteration

  // set by find method
  protected boolean found;         // true if element found, else false
  protected LLObjectNode location; // node containing element, if found
  protected LLObjectNode previous; // node preceeding location

  protected LLObjectNode list;     // first node on the list

  public RefList()
  {
    numElements = 0;
    list = null;
    currentPos = null;
  }

  protected void find(Object target)
  // Searches list for an occurence of an element e such that
  // e.equals(target). If successful, sets instance variables
  // found to true, location to node containing e, and previous
  // to the node that links to location. If not successful, sets 
  // found to false.
  {
    boolean moreToSearch;
    location = list;
    found = false;

    moreToSearch = (location != null);
    while (moreToSearch && !found) 
    {
      if (location.getInfo().equals(target))  // if they match
       found = true;
      else
      {
        previous = location;
        location = location.getLink();
        moreToSearch = (location != null);
      }
    }
  }

  public int size()
  // Returns the number of elements on this list. 
  {
    return numElements;
  }

  public boolean contains (Object element)
  // Returns true if this list contains an element e such that 
  // e.equals(element); otherwise, returns false.
  {
    find(element);
    return found;
  }

  public boolean remove (Object element)
  // Removes an element e from this list such that e.equals(element)
  // and returns true; if no such element exists, returns false.
  {
    find(element);
    if (found)
    {
      if (list == location)     
        list = list.getLink();    // remove first node
      else
        previous.setLink(location.getLink());  // remove node at location

      numElements--;
    }
    return found;
  }

  public Object get(Object element)
  // Returns an element e from this list such that e.equals(element);
  // if no such element exists, returns null.
  {
    find(element);    
    if (found)
      return location.getInfo();
    else
      return null;
  }
  
  public String toString()
  // Returns a nicely formatted string that represents this list.
  {
    LLObjectNode currNode = list;
    String listString = "List:\n";
    while (currNode != null)
    {
      listString = listString + "  " + currNode.getInfo() + "\n";
      currNode = currNode.getLink();
    }
    return listString;
  }  

  public void reset()
  // Initializes current position for an iteration through this list,
  // to the first element on this list.
  {
    currentPos  = list;
  }

  public Object getNext()
  // Preconditions: The list is not empty
  //                The list has been reset
  //                The list has not been modified since most recent reset
  //
  // Returns the element at the current position on this list.
  // If the current position is the last element, then it advances the value 
  // of the current position to the first element; otherwise, it advances
  // the value of the current position to the next element.
  {
    Object next = currentPos.getInfo();
    if (currentPos.getLink() == null)
      currentPos = list;
    else
      currentPos = currentPos.getLink();
    return next;
  }
}

package Homework;

//----------------------------------------------------------------------------
// LLObjectNode.java            by Dale/Joyce/Weems                  Chapter 3
//
// Implements Object nodes for a Linked List.
//----------------------------------------------------------------------------



public class LLObjectNode 
{
  private LLObjectNode link;
  private Object info;
  
  public LLObjectNode(Object info)
  {
    this.info = info;
    link = null;
  }
 
  public void setInfo(Object info)
  // Sets info Object of this LLObjectNode.
  {
    this.info = info;
  }

  public Object getInfo()
  // Returns info Object of this LLObjectNode.
  {
    return info;
  }
 
  public void setLink(LLObjectNode link)
  // Sets link of this LLObjectNode.
  {
    this.link = link;
  }

  public LLObjectNode getLink()
  // Returns link of this LLObjectNode.
  {
    return link;
  }
}
 
 

package Homework;


public class UseLists
{
    public static void main(String[] args)
    {
        RefUnsortedList list = new RefUnsortedList();
        
        list.add( "Mark" );
        list.add( "Joel" );
        list.add( "Kathy" );
        list.add( "Susan" );
        list.add( "Jim" );
        
        System.out.print( list );
        
        list.endInsert( "Julien");
        System.out.print( list );
        
        list.endInsert( "David" );
        System.out.print( list );
        
        list.endInsert( "Tim" );
        System.out.print( list );
        
        
        System.out.println( "\nTesting ReferenceUnsortedList removeAll method : ");
        
        list.removeAll( list );
        System.out.printf( "List contains: %d elements\n", list.numElements );
        
    }
}

FAT32 SHAMER fucked around with this message at 05:41 on Apr 4, 2014

while( list != null )
{
	if( find( null ) == null
	{
		list = find( null );
	}
	else
		return;

FAT32 SHAMER fucked around with this message at 07:43 on Apr 4, 2014

Smarmy Coworker fucked around with this message at 18:50 on Apr 4, 2014

BirdOfPlay fucked around with this message at 09:56 on Apr 6, 2014

Brain Candy fucked around with this message at 12:50 on Apr 6, 2014

Smarmy Coworker fucked around with this message at 23:44 on Apr 7, 2014