基于路径压缩和路径分裂的并查集（Quick Union实现）

//通用的数据结构实现
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

public class GenericUnionFind<V> {

  public Map<V, Node<V>> nodes = new HashMap<>();

  public void makeSet(V v) {
    if (nodes.containsKey(v)) {
      return;
    }
    Node<V> node = new Node<V>(v);
    nodes.put(v, node);
  }

  private Node<V> findNode(V v) {
    Node<V> node = nodes.get(v);
    if (node == null)
      return null;

    while (!Objects.equals(node.value, node.parent.value)) {
      node.parent = node.parent.parent;
      node = node.parent;
    }
    return node;
  }

  public V find(V v) {
    Node<V> node = findNode(v);
    return node == null ? null : node.value;
  }

  public void Union(V v1, V v2) {
    Node<V> p1 = findNode(v1);
    Node<V> p2 = findNode(v2);
    if (p1 == null || p2 == null) {
      return;
    }
    if (Objects.equals(p1.value, p2.value)) {
      return;
    }

    if (p1.rank < p2.rank) {
      p1.parent = p2;
    } else if (p1.rank > p2.rank) {
      p2.parent = p1;
    } else {
      p1.parent = p2;
      p2.rank += 1;
    }
  }

  public boolean isSame(V v1, V v2) {
    return Objects.equals(find(v1), find(v2));
  }

  private static class Node<V> {
    public V value;
    Node<V> parent = this;
    int rank = 1;

    public Node(V value) {
      this.value = value;
    }
  }
}