CS 161 Assignment #8

Introduction

Teams

Discussion

If we kept the items in the list ordered instead, we could use binary search when checking for items, which would be much faster. That means we'd need to be careful when adding new items, to ensure that the list stayed ordered, but binary search can help us here too! As described below, binary search can get us to the position at which a new item needs to be inserted to keep the list ordered. Your job will be to fill in the missing methods to create a set for holding integer values.

The Assignment

    private ArrayList<Integer> values; 

1. As mentioned above, we can use binary search when looking for items in our set, but it will also come in handy when adding items. Since binary search will be used in several other methods, let's start by writing a find method that can be used as a "helper" elsewhere: It should take an int as its input and use binary search to narrow the search down to a single location in the values ArrayList, but instead of checking whether the "key" really is at that location it should return the index of that final "box".

   You'll need to adapt our binary search code from class so that it works on ArrayLists, but the required changes should be pretty minimal. Also, while you might want to leave this method public until you've finished testing your code, it should be private in the final version you submit. This is not a method we want the user to access — it's only there to assist in the implementation of other methods within the class. Also, for full credit, make sure you use your find method in the rest of your code any time you need to search the ArrayList. (Do not use methods like contains or indexOf on the values list elsewhere in your class.)

2. Define a toString method for the IntSet class that returns a string containing all of the integer values stored in the set. It's fine if this string looks exactly like the results of ArrayList's toString method. (That was a hint.)
3. Define a size method that returns the number of integers in the IntSet. (If this is more than one line of code, you made it harder than it needed to be.)
4. Define a method called contains that takes an integer as its input and returns true if the item is in the set (false if it's not). Since you already implemented binary search in the find method, there's not much to do here: Call find to see where the item would be located if it were in the ArrayList, then check that one position to see if it's there.
5. Define a void method called add that takes an integer as its input, and adds it to the set if it's not already present. This requires a bit of care, since we need to keep the list ordered. Here's a start at a to-do list:
   • If the list is empty, add the value and we're done
   • If it's not empty, use find to figure out where it should be and...
     • If it's already at that position we're done (we don't want duplicates)
     • If the new value is < what's there, add at position find returned
     • If the new value is > what's there, add it to the right of that position
   Note: Don't use the sorting code we developed in class as part of your solution — it's much more efficient to use find as described above to add the value in the right spot since the list is already in order before the call to add.
6. Define a void method called merge that takes an IntSet as its input, and adds all of the items from the input set to the current set. (Hint: You just need to call the add method from the previous step a bunch of times — once for each item in the input set.)
7. Define a void method called remove that takes an integer as its input and removes that value from the set if it was present. The find method is your friend here as well:
   • If the list is empty we're done. There's nothing to remove
   • If it's not empty, call find to see where the item would be
     • If the item at that position matches the one we're supposed to remove, remove it from the list
     • If some other item is at that position, no need to do anything — the specified item wasn't in the set
8. Define a void method called subtract that takes an IntSet as its input, and removes all items in that set from our current set. Just like merge, this just means calling remove once for each item in the input set.

Sample Interactions

IntSet s = new IntSet();
s.add(20);
s.add(10);
s.add(30);
s.add(5);
s.add(30);
s.toString()
  "[5, 10, 20, 30]"   (String)
s.size()
  4   (int)
s.find(5)
  0   (int)
s.find(4)
  0   (int)
s.find(25)
  2   (int)
s.find(35)
  3   (int)
s.contains(5)
  true   (boolean)
s.contains(30)
  true   (boolean)
s.contains(15)
  false   (boolean)
s.remove(15);
s.remove(20);
s.remove(5);
s.toString()
  "[10, 30]"   (String)

Style Guide

• No unused variables or commented-out code is left in the class
• All instance variables are used in more than one method (if not, make them local)
• Useful Javadoc comment at the top of the class (including your name)
• All methods have Javadoc comments, including @param and @return tags
• Specific values have been replaced with constants (i.e. no "magic numbers")
• Proper capitalization of variables, methods, and classes
• Use white space to separate different sections of your code
• Methods defined in the specified order

Grading

• [25] find() method
• [10] toString() and size() methods
• [10] contains() method
• [25] add() and merge() methods
• [20] remove() and subtract() methods
• [10] Style and commenting

Submitting