Lecture 16 Handout

Learning Outcomes

At the end of this lecture, you’ll be able to:

• Explain and trace the core operations of Set ADT.
• Implement the core operations of Set efficiently using array/linked structure.
• Analyze the time/space efficiency of alternative implementation approaches (e.g. array vs linked structure)
• Understand “move-to-front” and “transpose sequential search” heuristics well enough to implement them.
• Implement Fail-Fast iterators for the Set ADT.
• Explain the difference between the Set and the OrderedSet ADT.
• Implement the core operations of OrderedSet efficiently using array/linked structure.
• Describe set-theoretical operations union, intersection, and set difference.

A set is an iterable collection of unique elements. A set has no particular ordering of elements (neither by position nor by value).

/**
 * Sets of arbitrary values (not necessarily Comparable).
 * Iteration order is undefined.
 *
 * @param <T> Element type.
 */
public interface Set<T> extends Iterable<T> {
  /**
   * Insert a value.
   * Set doesn't change if we try to insert an existing value.
   * Post: has(t) == true.
   *
   * @param t Value to insert.
   */
  void insert(T t);

  /**
   * Remove a value.
   * Set doesn't change if we try to remove a non-existent value.
   * Post: has(t) == false.
   *
   * @param t Value to remove.
   */
  void remove(T t);

  /**
   * Test membership of a value.
   *
   * @param t Value to test.
   * @return True if t is in the set, false otherwise.
   */
  boolean has(T t);

  /**
   * Number of values.
   *
   * @return Number of values in the set, always greater equal to 0.
   */
  int size();
}

We want to efficiently implement the Set ADT with an underlying linked list. (Go for the simplest choice, singly linked list, unless efficiently demands more complex structures.)

Exercise Complete the following table.

Exercise Open the starter code and complete the implementation of LinkedSet. (Do this at home!)

Consider the following implementation of find:

private Node<T> find(T t) {
  for (Node<T> n = head; n != null; n = n.next) {
    if (n.data.equals(t)) {
      return n;
    }
  }
  return null;
}

Exercise Update the implementation of find to employ the “move-to-front heuristic” as it is described in the “Dictionary of Algorithms and Data Structures”.

private Node<T> find(T t) {
  for (Node<T> n = head; n != null; n = n.next) {
    if (n.data.equals(t)) {
      remove(n);   // removes node n from this list
      prepend(n.data);  // add to the front of this list
      return head; // assuming no sentinel node 
    }
  }
  return null;
}

We want to efficiently implement the Set ADT with an array as the underlying data structure.

Exercise Complete the following table.

Exercise Open the starter code and complete the implementation of ArraySet. (Do this at home!)

Recall we can use a heuristic that moves the target of a search to the head of a list so it is found faster next time. This technique is called “move-to-front heuristic”. It speeds up linear search performance in linked list, if the target item is likely to be searched for again soon.

Exercise Can we apply the move-to-front heuristic to speed up linear search in an array?

We know set is an unordered collection.

Exercise How should we implement the iterator for Set ADT?

A) Simply iterate in the same order the elements have been added.
B) To ensure this is an unordered collection, we must iterate over the elements in a random order.
C) Iterate over the elements from head to tail (from index 0 to numElements - 1 in array).

Have you ever thought about what will happen if you structurally modify a data structure while you are iterating over it?

Assume you are iterating over an ArraySet. While the iteration going one, an element you’ve already visited (iterated over) is removed. This could happen in a concurrent program but here is a contrived example to showcase this scenario:

for (int num: myArraySet) {
  // do something with num
  if (feelingLucky()) {
    myArraySet.remove(num);
  }
}

Exercise Can you anticipate any issues with iteration?

When that happens, the iterator will throw ConcurrentModificationException.

Iterators that do this are known as fail-fast iterators, as they fail quickly and cleanly, rather that risking arbitrary, non-deterministic behavior at an undetermined time in the future.

Exercise How can you make a iterator “fail-fast”?

Hint: To make an iterator “fail-fast” we need to be able to tell that the data structure has been modified since the iteration started.

An ordered-set is an iterable collection of ordered unique elements. The elements are expected to be iterated over in order, based on their values.

/**
 * Ordered set of arbitrary values.
 * Iteration order is based on the values.
 *
 * @param <T> Element type.
 */
public interface OrderedSet<T extends Comparable<T>> extends Set<T> {
  // Same operations as the Set ADT
}

Notice we must use bounded generics to ensure the elements are comparable (otherwise we cannot put them in order).

We want to efficiently implement the OrderedSet ADT with an underlying linked list.

Exercise Complete the following table.

We want to efficiently implement the OrderedSet ADT with an array as the underlying data structure.

Exercise Complete the following table.

In Mathematics, two sets can be “added” together. The union of $A$ and $B$, denoted by $A \cup B$, is the set of all elements that are members of either $A$ or $B$.

We can include this operation in the Set ADT:

/**
 * Constructing a new set with elements that are in this set or
 * in the other set.
 *
 * @param other set.
 * @return all elements that are in this set or the other set.
 */
Set<T> union(Set<T> other);

The intersection of $A$ and $B$, denoted by $A \cap B$, is the set of all elements that are members of both $A$ and $B$.

/**
 * Constructing a new set with elements that are in this set and
 * in the other set.
 *
 * @param other set.
 * @return the elements this set and other set have in common.
 */
Set<T> intersect(Set<T> other);

The set difference of $A$ and $B$, denoted by $A - B$, is the set of all elements that are in $A$ but not in $B$.

/**
 * Constructing a new set with elements that are in this set but not
 * in the other set.
 *
 * @param other set.
 * @return the elements in this set but not in the other set.
 */
Set<T> subtract(Set<T> other);

These operations can be defined for OrderedSet ADT as well:

OrderedSet<T> union(OrderedSet<T> other); 
OrderedSet<T> intersect(OrderedSet<T> other);  
OrderedSet<T> subtract(OrderedSet<T> other);  

We leave it to you as a challenge> exercise to implement these operations efficiently.