Question

Create a linked list with given code

Given code:

import java.util.Iterator;

public interface Set {
   
   /**
      Removes all of the elements from this set
   */
   void clear();
   
   /**
      Returns true if this set contains no elements
      @return true if this set contains no elements
   */
   boolean isEmpty();
   
   /**
      Returns the number of elements in this set (its cardinality)
      @return the number of elements in this set
   */
   int size();
   
   /**
      Returns an iterator over the elements in this set
      @return an iterator over the elements in this set
   */
   Iterator iterator();

   /**
      Returns true if this set contains the specified element
      @param e element whose presence in this set is to be tested
      @return true if this set contains the specified element
   */
   boolean contains (E e);
   
   /**
      Adds the specified element to this set if it is not already present
      @param e element to be added to this set
      @return true if this set did not already contain the specified element
   */
   boolean add (E e);
   
   /**
      Removes the specified element from this set if it is present
      @param e element to be removed from this set, if present
      @return true if this set contained the specified element
   */
   boolean remove (E e);
}
   
Task #1. Develop the class LinkedSet 
Assuming you already have the file Set.java saved in your working directory, open it and look for all the methods you need to implement the Set interface. Develop your LinkedSet class in a file named LinkedSet.java with the prototype 

public class LinkedSet implements Set

Your class should consist of the following members. Decide upon the access specifier to use for each of these members, including the nested classes. Use the linked list class examples as guidelines, but the recommendation is that you develop the iterator class first and implement the set interface methods using the iterator methods

A nested node class for storing elements of type E and reference to the next node
  o Data fields (note that the outer class has direct access to inner class data) 
  o Method, including constructors

A nested iterator class implementing the iterator interface
  private class LinkedSetIterator implements Iterator
  o Carefully choose the data fields. How many reference variables are needed? 
  o Decide upon whether to make constructors public—this depends on how you plan on instantiating an iterator. 
  o Methods enforced by the iterator interface 
     hasNext to check if there is any more element 
     next to return the next element 
     remove to remove the element returned by last call to next

Data fields needed for the whole set object
Methods enforced by the set interface (as per downloaded Set.java)
  o clear to remove all elements from the set 
  o isEmpty to check if the set has no elements o size to find the number of elements in the set 
  o iterator to get a new instance of set iterator 
  o contains to check if a given element is in the set 
  o add to check if a given element is not in the set and subsequently added (new elements are always added to the front of the underlying linked list) 
  o remove to check if a given element is in the set and subsequently removed
  o toString to print the whole set (element by element printing can be easily done using the iterator, which we already have).


No need to do every bullet point completely, I just need to know mainly how to start the code and how to incorporate set.java into it.
  

Answer 1

Given below is the code for the question. Please do rate the answer if it helped. Thank you.

Set.java
---
import java.util.Iterator;

public interface Set<E extends Comparable<E>> {

/**
Removes all of the elements from this set
*/
void clear();

/**
Returns true if this set contains no elements
@return true if this set contains no elements
*/
boolean isEmpty();

/**
Returns the number of elements in this set (its cardinality)
@return the number of elements in this set
*/
int size();

/**
Returns an iterator over the elements in this set
@return an iterator over the elements in this set
*/
Iterator iterator();

/**
Returns true if this set contains the specified element
@param e element whose presence in this set is to be tested
@return true if this set contains the specified element
*/
boolean contains (E e);

/**
Adds the specified element to this set if it is not already present
@param e element to be added to this set
@return true if this set did not already contain the specified element
*/
boolean add (E e);

/**
Removes the specified element from this set if it is present
@param e element to be removed from this set, if present
@return true if this set contained the specified element
*/
boolean remove (E e);
}

LinkedSet.java
-----
import java.util.Iterator;

public class LinkedSet<E extends Comparable<E>> implements Set<E>
{
   class Node{
       E data;
       Node next;
       Node(E val, Node nxt){
           data = val;
           next = nxt;
       }
   }

   private Node head;

   /**
       Removes all of the elements from this set
   */
   public void clear(){
       head = null;
   }

   /**
       Returns true if this set contains no elements
       @return true if this set contains no elements
   */
   public boolean isEmpty(){
       return head == null;
   }

   /**
       Returns the number of elements in this set (its cardinality)
       @return the number of elements in this set
   */
   public int size(){
       int count = 0;
       for(Node n = head; n != null; n = n.next)
           count++;
       return count;
   }

   /**
       Returns an iterator over the elements in this set
       @return an iterator over the elements in this set
   */
   public Iterator iterator(){
       return new LinkedSetIterator();
   }

   /**
       Returns true if this set contains the specified element
       @param e element whose presence in this set is to be tested
       @return true if this set contains the specified element
   */
   public boolean contains (E e){
       for(Node n = head; n != null; n=n.next)
       {
           if(n.data.equals(e))
               return true;
       }
       return false;
   }

   /**
       Adds the specified element to this set if it is not already present
       @param e element to be added to this set
       @return true if this set did not already contain the specified element
   */
   public boolean add (E e){
       if(!contains(e)){
           head = new Node(e, head);
           return true;
       }
       else
           return false;
   }

   /**
       Removes the specified element from this set if it is present
       @param e element to be removed from this set, if present
       @return true if this set contained the specified element
   */
   public boolean remove (E e){
       Node prev = null, curr = head;
       while(curr != null && !curr.data.equals(e)){
           prev = curr;
           curr = curr.next;
       }
       if(curr == null) //not found
           return false;

       if(curr == head) //remove head node?
           head = head.next;
       else
           prev.next = curr.next;
       return true;
   }

   class LinkedSetIterator implements Iterator<E>{
       Node curr;

       public LinkedSetIterator(){
           curr = head;
       }

       public boolean hasNext(){
           return curr != null;
       }

       public E next(){
           return curr.data;
       }
   }
}