CS 307Assignment, Sets (a.k.a. The Mother of All Assignments.)

Programming Assignment 7: This is a pair assignment. You may work with one other person on this assignment using the pair programming technique. Review this paper on pair programming. You are not required to work in a pair on the assignment. If you begin working with one partner and do not wish to finish the assignment with that partner you must complete the assignment individually. If you work with a partner the intent is that work together, at the same computer, on the assignment. One person "drives" (does the typing and explains what they are doing) and the other person "navigates" (watches and asks questions when something is unclear). You should not partition the work, work on your own, and then put things together. You may not acquire, from any source (e.g., another student or student pair or an internet site), a partial or complete solution to a problem or project that has been assigned. You may not show another student or student pair your solution to an assignment. You may not have another person (current student, former student, tutor, friend, anyone) “walk you through” how to solve an assignment. Review the class policy on collaboration from the syllabus.

If you work with a partner you will turn in one version of your code. Pick only one account to submit the code to.

If you are working with a partner and want to use slip days you must both have the required number of slip days and both students use slip days. If the assignment is turned in 1 day late each student in a pair must have at least 1 slip day and it costs each student in the pair 1 slip day.

• Placed online: Friday, July 23
• 20 points, ~2% of final grade.
• Due: no later than 11 pm, Monday, August 2
• General Assignment Requirements

Description: The purposes of this assignment are:

1. to practice implementing data structures
2. to use ArrayLists and Iterators
3. to implement sorting and searching algorithms
4. To develop code that makes use of encapsulation, inheritance, and polymorphism.

In this assignment you will be implementing three classes. AbstractSet, UnsortedSet, and SortedSet. Recall that the elements in a set has no order and duplicate items are not allowed. Link to the Wikipedia entry on Sets. For more details on how to complete the assignment see the description of classes and files below as well as the tips section.

Very Important: On this assignment you must use an ArrayList as your internal storage container in the UnsortedSet and SortedSet classes.

Very Important: On this assignment you may not use any of the methods in the Arrays or Collections classes. You are encouraged to use methods from the ArrayList class.

Very Important: For each method you write in UnsortedSet and SortedSet state the Big O of the method in a comment at the top of the method. To answer some of these questions you have to determine the Big O of methods from the ArrayList class. View the ArrayList documentation and think about how we implemented methods in our simple array-based List class to determine the Big O of methods from ArrayList. Use the class listserv to discuss what you think the Big O of methods from ArrayList are.

You may ignore any warnings about type safety in your code. When grading you will not lose points if you have warnings regarding type safety.

Provided files:

Description of Classes and Files:

ISet: The provided source file ISet.java contains the interface. Do not edit it.

AbstractSet: The provided source file AbstractSet.java is a skeleton file.

• Do not include any instance variables in this class, but implement as many methods as you can in terms of other methods, regardless of efficiency.
• Do not rely or assume any sub class implementations. In other words AbstractSet shall not make any references to SortedSet, UnsortedSet, or ArrayList.
• AbstractSet can and should use the iterator method and Iterator objects. You may assume the Iterator class implements the remove method.
• Recall you can use other methods besides iterator. For example the equals method could make use of the contains and /or containsAll methods.
• Realize there are some methods that cannot be implemented in AbstractSet. Part of this assignment is figuring out which methods can be implemented in AbstractSet and which ones can't. How can this be done if there is no storage container? Where possible use the Iterator object provided by the iterator method along with other abstract methods. See the example below. Implement one of intersection, union, or difference without adding any new methods to any classes or making reference to UnsortedSet or SortedSet.
•  For the purposes of this assignment, two objects that are both ISets are equal if they contain the same elements. The status of sorted or unsorted does not matter when checking for equality in AbstractSet. This means it is possible that an UnsortedSet will equal a SortedSet. This convention is used in much of the Java standard library. Try it with LinkedList and ArrayList.) You should be able to implement the equals method in the AbstractSet class, but may have to override it in SortedSet.
• I have included a toString method as another example of how to use an iterator. You can use this method to print out your set objects during testing.

UnsortedSet: The provided source file UnsortedSet.java is a skeleton file. This is a class that extends AbstractSet. The elements in this set are not maintained in any particular order from the client's stand point.  (other code that uses UnsortedSet) Complete this class.

• Use an ArrayList of Es as the internal storage container. This class maintains the elements of the set it represents in unsorted order.
• Override methods from AbstractSet if you can implement them more efficiently. See the section below on target Big O's for methods.
• Implement methods that were not implemented in AbstractSet.
• For methods that return an ISet such as union, intersection, and difference, return an instance of UnsortedSet if the calling object is an UnsortedSet. (Which it must be to reach the code in UnsortedSet.).

SortedSet: The provided source file SortedSet.java is a skeleton file. This is a class that extends AbstractSet. The elements in this set are maintained in sorted order. To do this the data type that E (data type parameter) holds must be a class that implements the Comparable interface. The class header for SortedSet modifies E so that we know all variables of type E in SortedSet will be data types that implement Comparable.

• Use an ArrayList of Es as the internal storage container. 
• This class maintains the elements of the set it represents in ascending order. Override methods from AbstractSet if you can implement them more efficiently. See the section below for the target Big O's of methods.
• Implement methods that were not implemented in AbstractSet.
• This class adds a constructor to build a SortedSet out of an ISet<E>.
• The class adds method to get the min and max values in the SortedSet.
• For methods that return an ISet such as union, intersection, and difference, return an instance of SortedSet.

SetTester: The provided source file SetTester.java contains some tests for the set classes. I intend for all of the tests are correct for this assignment. Add at least 1 test per method per class that implements that method to this file. (In other words if there is a method in AbstractSet and you do not override it in UnsortedSet or SortedSet, you just need to write one test for that method. On the other hand if there is a method in AbstractSet that you do override in both UnsortedSet and SortedSet you have to write code for both versions.) You do not have to test the constructors. Use the class listserv to share new test cases.

When writing code that performs sorts and searches you may use code from the book or slides, except other pairs of students in the class, as long as you document the source with a comment. For example:

// code for binary search from class slides
... binary search code

Where to start: It may be difficult to know where to start with this assignment. You don't want to write all the code and then try and test it. Tracking down the errors can be a real problem. You may find it useful to change AbstractSet so that it does not implement ISet. UnsortedSet still extends AbstractSet so you can create instances of UnsortedSet and test the methods you wrote from AbstractSet. Just be sure to go back and have AbstractSet implement ISet.

Experiments:

When your classes are completed, run the method largeTest in the SetTester class. This method has you pick a file and then adds all of the words in the file to various Sets. The method uses the SortedSet, the UnsortedSet, the Java HashSet, and Java TreeSet. The time is displayed for the operation to execute. Test this method with a small file at first to ensure it works. Then files (again Project Gutenberg is a good source) of various sizes. Report your results in a comment at the top of the SetTester class. Also answer the following questions in that comment:

• What do you think the Big O of the two processText methods are for each kind of Set?
• Can Big O be meaningful when the data type sent to a method can vary? How do you address this problem?
• What are the Big Os of your add methods? What do you think the Big O of the HashSet and TreeSet add methods are?
• What are the differences between HashSet and TreeSet when printing out the contents of the Set?

Submission: When finished turn in a jar file named A8.jar that contains your AbstractSet.java, UnsortedSet.java, SortedSet.java, and SetTester.java, classes using the turnin program. jar is a program included in the standard edition of Java loaded on the computers in the Microlab and that you have on your computer if you downloaded Java. See my page on creating jars in eclipse, Sun's page for using jar, my tips for using jar, and / or the guide to creating jars in Eclipse.

Checklist:  Did you remember to:

• review and follow the general assignment requirements?
• work on the assignment with at most, one other person?
• complete all the required classes?
• not add any instance variables to AbstractSet?
• implement as many methods as you can in AbstractSet?
• override methods from AbstractSet in SortedSet and UnsortedSet if you can create a more efficient version??
• state the Big O of all your methods in UnsortedSet and SortedSet?
• pass the tests in SetTester.java and add your own tests?
• complete the experiments in the section named Experiments and place your answers in a comment at the top of the SetTester class?
• package all the required files in a jar file named A7.jar?
• fill in the header with your information in SetTester.java?
• turn in your jar file named A7.jar no later than 11 pm, Monday, August 2.

UnsortedSet Target Big Os:

These are the Big O's you should be able to achieve for the methods in the  UnsortedSet class. If a method is implemented in AbstractSet and it has this Big O then there is no need to override it in UnsortedSet. Assume there are already N elements in this UnsortedSet. For methods with another set assume there are N elements in that set as well.

• add -> O(N)
• addAll -> O(N^2)
• clear -> O(N) This is a little fuzzy. You can do this with a single statement in UnsortedSet, but the Big O of that statement is O(N).
• contains -> O(N)
• containsAll -> O(N^2) Worst case is this set does contain all of the elements of the other set and recall we are assuming the sets both contain N elements.
• difference -> O(N^2)
• equals -> O(N^2) Worst case, assuming the sets are equal.
• intersection -> O(N^2)
• iterator -> O(1). Remember, your internal storage container is an ArrayList and ArrayList already has a method to get an Iterator.
• remove -> O(N)
• size -> O(1)
• union -> O(N^2)

SortedSet Target Big Os:

These are the Big O's you should be able to achieve for the methods in the  SortedSet class. If a method is implemented in AbstractSet and it has this Big O then there is no need to override it in SortedSet. Assume there are already N elements in this SortedSet. For methods that involve two sets, the calling object and another ISet, these target Big Os apply only if the other set is also a SortedSet. if it is not your target Big O is the same as in the UnsortedSet class. If there is a method where the other set is not a SortedSet or it is a SortedSet that contains elements of a type different than those in this SortedSet you should rely on the Big O targets from UnsortedSet.

• SortedSet(UnsortedSet otherSet) -> O(NlogN)
• add -> O(N)
• addAll -> O(N) Use an algorithm like merge from mergesort.
• clear -> O(N) You can do this with a single statement in SortedSet, but the Big O of that statement is O(N).
• contains -> O(logN)
• containsAll -> O(N) Worst case is this set does contain all of the elements of the other set and recall we are assuming the sets both contain N elements.
• difference -> O(N)
• equals -> O(N) Worst case, if other is a SortedSet and assuming the sets are equal.
• intersection -> O(N)
• iterator -> O(1). Remember, your internal storage container is an ArrayList and ArrayList already has a method to get an Iterator.
• remove -> O(N)
• size -> O(1)
• union -> O(N)

Tips: So how can you implement methods in AbstractSet when there isn't an internal storage container or any instance variables and without making references to the sub classes? By using other methods in the class.

Here is an example. The ISet interface has a contains method that determines if a given element is in the set. There is also a method named iterator which provides an Iterator object to look at all the items in the set. So in AbstractSet we could do the following:

public boolean contains(Object item){
    boolean found = false;
    Iterator it = this.iterator(); // get an iterator for this set.
    Object temp;
    // do a linear search using the iterator object
    while( !found && it.hasNext() ){
        temp = it.next();
        found = temp.equals( item ); // which equals method is getting called?
    }
    return found;
}

You won't be able to implement the iterator method in the AbtsractSet class. You need an internal storage container to do that. So you will be calling a method that will be implemented later. Note the use of a temporary object in the above code is actually unnecessary and the code could be streamlined to this form.

public boolean contains(Object item){
    boolean found = false;
    Iterator it = this.iterator(); // get an iterator for this set.
    // do a linear search using the iterator object
    while( !found && it.hasNext() ){
        found = item.equals( it.next() ); // which equals method is getting called?
    }
    return found;
}

And there is an even simpler option. ISet extends the Java Iterable interface. This means it has a method that returns an Iterator object. It also means ISets  can be used as the set-expression in enhanced for loops. So the following works as well

public boolean contains(Object obj){
    for(Object val : this)
        if( val.equals(obj ) )
            return true;
    return false;
}

Use whatever form you are most comfortable with.

SortedSet tips:

In the SortedSet class when methods can be faster due to the fact that the data is sorted, you should make them faster. For example consider the contains method:

public boolean contains(Object item)

This could be implemented in the AbstractSet class using an Iterator object from the iterator method. The expected run time would be O(N). However, in the SortedSet class this method should be overridden, because it can be accomplished in O(log N) time through a binary search.

  Back to the CS 307 homepage.