Question

Modify the LinkedCollection class to be a SortedLinkedCollecton class and see how that effects our implementation for adding and removing items. You should reference the SortedArrayCollection class provided for how these algorithms should be implemented. What needs to change here? Is it a lot of code or not much?

Include a toString method that creates and returns a string that correctly represents the current collection. Include a test driver application that demonstrates your class correctly.

//---------------------------------------------------------------------------
// LinkedCollection.java
//
// Implements the CollectionInterface using a linked collection.
// Null elements are not allowed. Duplicate elements are allowed.
// One constructor is provided, one that creates an empty collection.
//---------------------------------------------------------------------------

package ch05.collections;

import support.LLNode;

public class LinkedCollection<T> implements CollectionInterface<T>
{
protected LLNode<T> head;       // head of the linked list
protected int numElements = 0; // number of elements in this collection

// set by find method
protected boolean found;        // true if target found, else false
protected LLNode<T> location;   // node containing target, if found
protected LLNode<T> previous;   // node preceding location

public LinkedCollection()
{
    numElements = 0;
    head = null;
}

public boolean add(T element)
// Adds element to this collection.
{
    LLNode<T> newNode = new LLNode<T>(element);
    newNode.setLink(head);
    head = newNode;
    numElements++;
    return true;
}

protected void find(T target)
// Searches the collection 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.
{
    location = head;
    found = false;

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

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

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

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

      numElements--;
    }
    return found;
}

public T get(T target)
// Returns an element e from this collection such that e.equals(target);
// if no such element exists, returns null.
{
    find(target);  
    if (found)
      return location.getInfo();
    else
      return null;
}
  
public boolean isEmpty()
// Returns true if this collection is empty; otherwise, returns false.
{
    return (numElements == 0);
}

public boolean isFull()
// Returns true if this collection is full; otherwise, returns false.
{
    return false; // Linked implementation is never full
}
}

//----------------------------------------------------------------------------
// SortedArrayCollection.java        by Dale/Joyce/Weems             Chapter 5
//
// Implements the CollectionInterface using a sorted array. The collection is
// stored in increasing order as defined by the compareTo method of the added
// elements. Only Comparable elements should be added to a collection. It is
// assumed that the compareTo method and equals method as defined for added
// elements are consistent.
//
// Null elements are not permitted in this collection.
//
// Two constructors are provided: one that creates a collection of a default
// original capacity, and one that allows the calling program to specify the
// original capacity. The collection is unbounded.
//----------------------------------------------------------------------------

package ch05.collections;

public class SortedArrayCollection<T> implements CollectionInterface<T>
{
protected final int DEFCAP = 100; // default capacity
protected int origCap;            // original capacity
protected T[] elements;           // array to hold collection elements
protected int numElements = 0;    // number of elements in this collection

// set by find method
protected boolean found; // true if target found, otherwise false
protected int location;   // indicates location of target if found,
                            // indicates add index if not found

public SortedArrayCollection()
{
    elements = (T[]) new Object[DEFCAP];
    origCap = DEFCAP;
}

public SortedArrayCollection(int capacity)
{
    elements = (T[]) new Object[capacity];
    this.origCap = capacity;
}

protected void enlarge()
// Increments the capacity of the collection by an amount
// equal to the original capacity.
{
    // Create the larger array.
    T[] larger = (T[]) new Object[elements.length + origCap];
  
    // Copy the contents from the smaller array into the larger array.
    for (int i = 0; i < numElements; i++)
    {
      larger[i] = elements[i];
    }
  
    // Reassign elements reference.
    elements = larger;
}

protected void find(T target)
// Searches elements for an occurrence of an element e such that
// e.equals(target). If successful, sets instance variables
// found to true and location to the array index of e. If
// not successful, sets found to false and location to the
// array index where target should be inserted.
{
    location = 0;
    found = false;
    if (!isEmpty())
       recFind(target, 0, numElements - 1);
}

protected void recFind(T target, int first, int last)
// Used by find.
{
    int result;       // result of the comparison
    if (first > last)
    {
      found = false;
      result = ((Comparable)target).compareTo(elements[location]);
      if (result > 0)
         location++;    // adjust location to indicate insert index
    }
    else
    {
      location = (first + last) / 2;
      result = ((Comparable)target).compareTo(elements[location]);
      if (result == 0) // found target
        found = true;
      else
      if (result > 0)   // target too high
        recFind(target, location + 1, last);
      else               // target too low
        recFind(target, first, location - 1);
     }
}

public boolean add(T element)
// Precondition: element is Comparable to previously added objects
//
// Adds element to this collection.
{
    if (numElements == elements.length)
      enlarge();

    find(element); // sets location to index where element belongs
  
    for (int index = numElements; index > location; index--)
      elements[index] = elements[index - 1];

    elements[location] = element;
    numElements++;
    return true;
}

public boolean remove (T target)
// Removes an element e from this collection such that e.equals(target)
// and returns true; if no such element exists, returns false.
{
    find(target);  
    if (found)
    {
      for (int i = location; i <= numElements - 2; i++)
        elements[i] = elements[i+1];
      elements[numElements - 1] = null;
      numElements--;
    }
    return found;
}

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

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

public T get(T target)
// Returns an element e from this collection such that e.equals(target);
// if no such element exists, returns null.
{
    find(target);  
    if (found)
      return elements[location];
    else
      return null;
}

public boolean isEmpty()
// Returns true if this collection is empty; otherwise, returns false.
{
    return (numElements == 0);
}

public boolean isFull()
// This collection is unbounded so always returns false.
{
    return false;
}
}

Answer 1

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/

/**
*
*
*/
//---------------------------------------------------------------------------
// LinkedCollection.java
//
// Implements the CollectionInterface using a linked collection.
// Null elements are not allowed. Duplicate elements are allowed.
// One constructor is provided, one that creates an empty collection.
//---------------------------------------------------------------------------

package ch05.collections;

import support.LLNode;

public class LinkedCollection<T> implements CollectionInterface<T>
{
protected LLNode<T> head; // head of the linked list
protected int numElements = 0; // number of elements in this collection

// set by find method
protected boolean found; // true if target found, else false
protected LLNode<T> location; // node containing target, if found
protected LLNode<T> previous; // node preceding location

public LinkedCollection()
{
numElements = 0;
head = null;
}

public boolean add(T element)
// Adds element to this collection.
{
LLNode<T> newNode = new LLNode<T>(element);
newNode.setLink(head);
head = newNode;
numElements++;
return true;
}

protected void find(T target)
// Searches the collection 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.
{
location = head;
found = false;

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

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

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

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

numElements--;
}
return found;
}

public T get(T target)
// Returns an element e from this collection such that e.equals(target);
// if no such element exists, returns null.
{
find(target);
if (found)
return location.getInfo();
else
return null;
}
  
public boolean isEmpty()
// Returns true if this collection is empty; otherwise, returns false.
{
return (numElements == 0);
}

public boolean isFull()
// Returns true if this collection is full; otherwise, returns false.
{
return false; // Linked implementation is never full
}
}

//----------------------------------------------------------------------------
// SortedArrayCollection.java by Dale/Joyce/Weems Chapter 5
//
// Implements the CollectionInterface using a sorted array. The collection is
// stored in increasing order as defined by the compareTo method of the added
// elements. Only Comparable elements should be added to a collection. It is
// assumed that the compareTo method and equals method as defined for added
// elements are consistent.
//
// Null elements are not permitted in this collection.
//
// Two constructors are provided: one that creates a collection of a default
// original capacity, and one that allows the calling program to specify the
// original capacity. The collection is unbounded.
//----------------------------------------------------------------------------

package ch05.collections;

public class SortedArrayCollection<T> implements CollectionInterface<T>
{
protected final int DEFCAP = 100; // default capacity
protected int origCap; // original capacity
protected T[] elements; // array to hold collection elements
protected int numElements = 0; // number of elements in this collection
protected int temp;
// set by find method
protected boolean found; // true if target found, otherwise false
protected int location; // indicates location of target if found,
// indicates add index if not found
boolean sorted=false;
public SortedArrayCollection()
{
elements = (T[]) new Object[DEFCAP];
origCap = DEFCAP;
while(!sorted)
{sorted=true;
for(int i=0; i<T.length; i++ ) // modifying for bubble sorting
{ if(T[i]>T[i+1])
{
temp=T[i];
T[i]=T[i+1];
T[i+1]=T[i];
sorted=false;   
}
}
}
  
  
  
}

public SortedArrayCollection(int capacity)
{
elements = (T[]) new Object[capacity];
this.origCap = capacity;
}

protected void enlarge()
// Increments the capacity of the collection by an amount
// equal to the original capacity.
{
// Create the larger array.
T[] larger = (T[]) new Object[elements.length + origCap];
  
// Copy the contents from the smaller array into the larger array.
for (int i = 0; i < numElements; i++)
{
larger[i] = elements[i];
}
  
// Reassign elements reference.
elements = larger;
}

protected void find(T target)
// Searches elements for an occurrence of an element e such that
// e.equals(target). If successful, sets instance variables
// found to true and location to the array index of e. If
// not successful, sets found to false and location to the
// array index where target should be inserted.
{
location = 0;
found = false;
if (!isEmpty())
recFind(target, 0, numElements - 1);
}

protected void recFind(T target, int first, int last)
// Used by find.
{
int result; // result of the comparison
if (first > last)
{
found = false;
result = ((Comparable)target).compareTo(elements[location]);
if (result > 0)
location++; // adjust location to indicate insert index
}
else
{
location = (first + last) / 2;
result = ((Comparable)target).compareTo(elements[location]);
if (result == 0) // found target
found = true;
else
if (result > 0) // target too high
recFind(target, location + 1, last);
else // target too low
recFind(target, first, location - 1);
}
}

public boolean add(T element)
// Precondition: element is Comparable to previously added objects
//
// Adds element to this collection.
{
if (numElements == elements.length)
enlarge();

find(element); // sets location to index where element belongs
  
for (int index = numElements; index > location; index--)
elements[index] = elements[index - 1];

elements[location] = element;
numElements++;
return true;
}

public boolean remove (T target)
// Removes an element e from this collection such that e.equals(target)
// and returns true; if no such element exists, returns false.
{
find(target);
if (found)
{
for (int i = location; i <= numElements - 2; i++)
elements[i] = elements[i+1];
elements[numElements - 1] = null;
numElements--;
}
return found;
}

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

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

public T get(T target)
// Returns an element e from this collection such that e.equals(target);
// if no such element exists, returns null.
{
find(target);
if (found)
return elements[location];
else
return null;
}

public boolean isEmpty()
// Returns true if this collection is empty; otherwise, returns false.
{
return (numElements == 0);
}

public boolean isFull()
// This collection is unbounded so always returns false.
{
return false;
}
}
}
SSS

COMMENT DOWN FOR ANY QUERIES AND,

LEAVE A THUMBS UP IF THIS ANSWER HELPS YOU.