Lecture 06: Sets, Binary Search, Recursion

The USet ADT

  • The ADTs we’ve used in the past were based on Lists. A Set is more limited. There are no repeat items
    • Idea: Store a collection of distinct elements
    • S = { x1, x2, … xn }. The order of items does not matter. Ex: a Set of primary colors {“red”, “yellow”, “blue”} is the same as {“blue”, “red”, “yellow”}. The strings are not literally equal, but these Sets represent the same collection of items.
    • Equality vs semantic equivalence
      • Strict equality: Integer val1 = new Integer(2);
      • Integer val2 = new Integer(2);
      • What does val1 == val2 return? False, because they store different references. Var1 == var2 returns true if and only if var1 and var2 refer to the same object instance.
      • Semantic equivalence: Two instances are semantically equivalent if they represent the same value.
      • To test semantic equivalence, use .equals() method, which every class has (inherited for the Object class), and override it to act differently than ==.
      • var1.equals(var2) returns true when the two instances represent the same value in a sense defined for the class.
    • Want: If we added var1 to a set S, then asked if var2 is contained in S, we would expect the result to be “yes.” S does contain an Integer whose value is 2
    • All the elements in a Set are semantically different from each other - you cannot have var1 and var2 in the same set, because they both reference 2
  • USet ADT (SimpleUSet interface)
    • State: a set of elements
    • Operations:
      • find(y): Is there an element equivalent to y in the set? If so, return the address. (Not the value - the address) Otherwise, return null.
      • add(y): if there is some Xi satisfying y.equals(xi), return false. Otherwise, update state to {x1, …., xn, y} and return true.
      • remove(y): if there is some xi satisfying y.equals(xi), update state to {x1, x2, … , x(i-1), x(i+1, …. , xn} and return xi. Otherwise, return null
  • Implementing it
    • LinkedList (for assignment 2)
    • Array
      • Object[ ] contents
      • Find(y): Loop through array, checking if each element is equal to y: for i = 0 to n - 1, if (y.equals(xi)), return xi. If not, return null
      • Add(y): if (find(y) != null); return false; resize if necessary; set contents[n] = y
      • Remove(y): if find xi with y.equals(xi). apply list remove method to remove xi. return xi. otherwise return null
  • This is awful unless your set is… Sorted! (so we don’t have to look through every single element)
    • Sorted Sets
    • We now consider sets of elements that can be compared according to a “natural order” on the elements. That is, there is a notion of “less than” (formally a binary relation), denoted < such that given any two elements x, y, then precisely one of the following holds: x < y, y > x, x = y (semantic equivalence)
    • Binary search: pick an interval to look for elements, look at midpoint of the interval, and compare y to that interval value. If it’s greater, find the point between the midpoint and the last element (and compare that); if it’s lower, the point between the midpoint and the first element. Repeat!!