Introduction

Learning Outcomes

Set ADT

Set

Set ADT

Set Operations

Set ADT

The java.util.Set Interface

Set<Integer> a = new HashSet<>(List.of(1,2,3,4,5));
Set<Integer> b = new HashSet<>(List.of(3,4,5,6,7));
Set<Integer> uni = new HashSet<>(a);
uni.addAll(b);     // [1..7]
Set<Integer> both = new HashSet<>(a);
both.retainAll(b); // [3, 4, 5]
Set<Integer> diff = new HashSet<>(a);
diff.removeAll(b); // [1, 2]
a.containsAll(b);  // false

Set ADT · Step through the code

Code Trace: First Repeat via the Result of add

int firstRepeat(int[] a) {
  Set<Integer> seen = new HashSet<>();
  for (int x : a) {
    if (!seen.add(x))   // not added?
      return x;            // already there: a repeat
  }
  return -1;               // no repeats
}

Set Implementations

java.util.Set Implementations

for (String s : List.of("lemon", "peach", "fig", "lemon")) {
    hash.add(s);  linked.add(s);  tree.add(s);
}
// HashSet       → [lemon, fig, peach]   (bucket order: depends on hash)
// LinkedHashSet → [lemon, peach, fig]   (insertion order)
// TreeSet       → [fig, lemon, peach]   (alphabetical)

Set Implementations

Hash-Based Set

Set Implementations · Step through the code

Code Trace: add / contains (m = 7)

// fields: List<Integer>[] bucket; n; m = 7
boolean add(int x) {          // x ≥ 0
  int i = x % m;               // bucket no.
  for (int y : bucket[i])
    if (y == x) return false;  // already there
  bucket[i].add(x);
  n++;
  return true;
}
boolean contains(int x) {
  int i = x % m;
  for (int y : bucket[i])
    if (y == x) return true;
  return false;
}

Set Implementations

Tree-Based (Sorted) Set

Extra operations a sorted structure provides (S = {5, 10, 15, 20, 25, 30, 40}):

Set Implementations · Step through the code

Union and Intersection of Sorted Arrays (Two Pointers)

void unionIntersection(int[] a, int[] b,
    List<Integer> uni, List<Integer> both) {
  int i = 0, j = 0;
  while (i < a.length && j < b.length) {
    if (a[i] < b[j]) uni.add(a[i++]);
    else if (a[i] > b[j]) uni.add(b[j++]);
    else {                     // in both
      uni.add(a[i]);  both.add(a[i]);
      i++;  j++;
    }
  }
  while (i < a.length) uni.add(a[i++]);
  while (j < b.length) uni.add(b[j++]);
}

Set Implementations

Comparing Set Implementations

* average case (worst case O(n)). † a lookup is needed first to rule out duplicates. Union with a hash table: contains + add for each element of B.

Set Implementations

Sets as Bit Vectors (Bitsets)

Memory is U bits: a universe of 10⁶ elements ≈ 122 KB. If the universe is large but the set sparse (e.g. 3 elements, U = 10⁹), use a hash-based set.

Set Implementations · Step through the code

Code Trace: Set Algebra with Bit Operations

int a = 0, b = 0;
for (int x : new int[]{1, 3, 4})
  a |= 1 << x;          // set bit x
for (int x : new int[]{3, 5})
  b |= 1 << x;
int uni = a | b;        // union
int both = a & b;       // intersection
int diff = a & ~b;      // difference
boolean has3 = (a >> 3 & 1) == 1;

Multisets

Multiset (Bag)

Multisets

A Multiset in Java

class Multiset<E> {
    private final Map<E, Integer> counts = new HashMap<>();
    private int n = 0;                                   // number of elements, repeats included
    void add(E e) { counts.merge(e, 1, Integer::sum); n++; }  // 1 if absent, else +1
    int count(E e) { return counts.getOrDefault(e, 0); }
    boolean remove(E e) {
        Integer c = counts.get(e);
        if (c == null) return false;                     // e is absent
        if (c == 1) counts.remove(e);                       // counter would hit 0: delete entry
        else counts.put(e, c - 1);
        n--;
        return true;
    }
    int size() { return n; }
}

Multisets · Step through the code

Code Trace: Multiset Counters

void add(E e) {
  counts.merge(e, 1, Integer::sum);  n++;
}
int count(E e) {
  return counts.getOrDefault(e, 0);
}
boolean remove(E e) {
  Integer c = counts.get(e);
  if (c == null) return false;
  if (c == 1) counts.remove(e);
  else counts.put(e, c - 1);
  n--;
  return true;
}

Multisets

Multimap

Map<String, List<String>> m = new HashMap<>();
void put(String k, String v) {   // create an empty list if absent
  m.computeIfAbsent(k, x -> new ArrayList<>()).add(v);
}
List<String> get(String k) {
  return m.getOrDefault(k, List.of());
}

Unlike a multiset, it stores the values themselves, not just how many. With hashing, put / get are O(1)* and remove(k, v) is O(1 + list length).

Disjoint Sets (Union-Find)

Disjoint Sets and Union-Find

• Disjoint sets: a collection of sets that share no elements. Every element belongs to exactly one set.
• Union-Find (Disjoint Set Union, DSU) is the data structure that maintains them. It has two main operations:

Each set is a tree: every node points to its parent; the root points to itself and represents the set.

Disjoint Sets (Union-Find)

Magnet Example

Disjoint Sets (Union-Find)

The Find and Union Operations

find(x):
  if x.parent != x:
    x.parent = find(x.parent)  // path compression
  return x.parent

union(x, y):
  root1 = find(x)
  root2 = find(y)
  if root1 != root2:
    // make the root of one set
    // a child of the other's root
    root1.parent = root2

Disjoint Sets (Union-Find)

Mapping Objects to Indices

• Union-Find is most efficient on an array, with elements numbered 0..n−1.
• If the elements are letters, cities, people…, each object is first mapped to an index arbitrarily (but permanently), and the mapping is stored in a hash table.
• Then parent[i] = i starts every element as the root of its own set (makeSet).

Map<Character, Integer> index = new HashMap<>();   // 'E'→0, 'F'→1, …
int[] parent = new int[12];
for (int i = 0; i < 12; i++) parent[i] = i;              // 12 singleton sets

Disjoint Sets (Union-Find)

The Union Operation Step by Step

Disjoint Sets (Union-Find)

Another Idea: Quick-Find

• A flat array instead of a tree: id[i] = the set name of i; elements of the same set share an id. find(p) = id[p] → O(1).
• union(p, q): set every entry equal to id[p] to id[q] → the whole array is scanned, O(n).

after union(0,1), union(2,3): 4 sets (same color = same set)

Disjoint Sets (Union-Find) · Step through the code

Code Trace: Quick-Find union

int find(int p) { return id[p]; }  // O(1)
void union(int p, int q) {
  int pid = id[p], qid = id[q];
  if (pid == qid) return;
  for (int i = 0; i < id.length; i++)
    if (id[i] == pid)
      id[i] = qid;           // O(n) scan
}

Disjoint Sets (Union-Find)

Why Do We Need Improvements?

• find takes as many steps as the node's distance from the root. A bad sequence of unions turns the tree into a chain → O(n) in the worst case.

Disjoint Sets (Union-Find)

Union by Size

• Store each tree's size (number of elements) at its root.
• When merging, attach the root of the smaller tree to the root of the larger; the new size is the sum of the two.

Disjoint Sets (Union-Find)

Union by Rank

makeSet(x):
  parent[x] = x
  rank[x] = 0

find(x):   // with path compression
  if x != parent[x]:
    parent[x] = find(parent[x])
  return parent[x]

link(x, y):   // x, y are roots
  if rank[x] > rank[y]:
    parent[y] = x
  else:
    parent[x] = y
    if rank[x] == rank[y]:
      rank[y] = rank[y] + 1

union(x, y):
  link(find(x), find(y))

Disjoint Sets (Union-Find)

Path Compression

Path compression: during find, attach every node you pass directly to the root. Later finds finish in one step.

Disjoint Sets (Union-Find)

Union-Find Complexity

Disjoint Sets (Union-Find)

Java: Node-Based (Object) Union-Find

class SetNode {
  int data;
  int rank;   // bound on height
  SetNode parent;

  SetNode(int data) {
    this.data = data;
    this.parent = this;
    this.rank = 0;
  }
}

SetNode find(SetNode node) {
  if (node != node.parent)
    node.parent = find(node.parent); // compression
  return node.parent;
}

void union(SetNode x, SetNode y) {
  SetNode rootX = find(x);
  SetNode rootY = find(y);
  if (rootX == rootY) return;
  // union by rank
  if (rootX.rank < rootY.rank) {
    rootX.parent = rootY;
  } else if (rootX.rank > rootY.rank) {
    rootY.parent = rootX;
  } else { // equal: pick one
    rootX.parent = rootY;
    rootY.rank++;
  }
}

Disjoint Sets (Union-Find)

Java: Array-Based Union-Find

class UnionFind {
  private final int[] parent, rank;
  UnionFind(int n) {
    parent = new int[n];  rank = new int[n];
    for (int i = 0; i < n; i++) parent[i] = i;
  }
  int find(int x) {
    if (parent[x] != x) parent[x] = find(parent[x]);
    return parent[x];
  }
  boolean union(int x, int y) {
    int rx = find(x), ry = find(y);
    if (rx == ry) return false;
    if (rank[rx] < rank[ry]) parent[rx] = ry;
    else if (rank[rx] > rank[ry]) parent[ry] = rx;
    else { parent[rx] = ry; rank[ry]++; }
    return true;
  }
}

Disjoint Sets (Union-Find) · Step through the code

Code Trace: find + union

int find(int x) {
  if (parent[x] != x) parent[x] = find(parent[x]);
  return parent[x];
}
boolean union(int x, int y) {
  int rx = find(x), ry = find(y);
  if (rx == ry) return false;
  if (rank[rx] < rank[ry]) parent[rx] = ry;
  else if (rank[rx] > rank[ry]) parent[ry] = rx;
  else { parent[rx] = ry; rank[ry]++; }
  return true;
}