并查集问题

import java.util.HashMap;
import java.util.List;
import java.util.Stack;

public class test33 {
    //由若干样本a、b、c、d……假设类型为V
    //在并查集中开始认为每个样本都在单独的集合里
    //用户可以在任何时候调用如下方法:
    //1.boolean isSameSet(V x ,V y):查询样本x和样本y是否属于同一集合
    //2.void union(V x , V y):把x和y各自所在集合的所在样本合并成一个集合
    //isSameSet和union方法的代价越低越好

    public static class Node<V>{
        V value;

        public Node(V v){
            value =v;
        }
    }

    public static class UnionSet<V> {

        //通过V找节点
        public HashMap<V, Node<V>> nodes;

        //找一个节点的父节点
        public HashMap<Node<V>, Node<V>> parents;

        //只有一个点是某个集合代表点的时候才会记录数值
        public HashMap<Node<V>, Integer> sizeMap;

        //初始化
        public UnionSet(List<V> values) {
            for (V value : values) {
                Node<V> node = new Node<>(value);//建立节点
                nodes.put(value, node);//数据放进nodes表中
                parents.put(node, node);//所有样本的集合开始都是自己，故node的父亲都是自己
                sizeMap.put(node, 1);//每个值在自己的集合都为1，因为自己的集合只有自己一个值
            }
        }

        //从cur开始，一直往上找，找到不能再往上的代表点返回
        public Node<V> findFather(Node<V> cur){
            Stack<Node<V>> path = new Stack<>();

            while (cur != parents.get(cur)){
                path.push(cur);
                cur = parents.get(cur);
            }

            while (!path.isEmpty()){
                parents.put(path.pop() , cur);
            }

            return cur;
        }


        public boolean isSameSet(V a , V b){
            if(!nodes.containsKey(a) || !nodes.containsKey(b)){
                return false;
            }
            return findFather(nodes.get(a)) == findFather(nodes.get(b));
        }

        public void union(V a , V b){
            if(!nodes.containsKey(a) || nodes.containsKey(b)){
                return;
            }

            Node<V> aHead = findFather(nodes.get(a));
            Node<V> bHead = findFather(nodes.get(b));

            if(aHead != bHead){
                //拿到两个集合的大小
                int aSetSize = sizeMap.get(aHead);
                int bSetSize = sizeMap.get(bHead);

                //小的挂在大的上
                if(aSetSize >= bSetSize){
                    parents.put(bHead ,aHead);//把bHead的父改成aHead
                    sizeMap.put(aHead ,aSetSize + bSetSize);
                    //新的aHead为一个集合，数值包括aSetSize和bSetSize
                    sizeMap.remove(bHead);//aHead主导着bHead，故bHead删掉
                }else{
                    parents.put(aHead , bHead);
                    sizeMap.put(bHead , aSetSize + bSetSize);
                    sizeMap.remove(aHead);
                }
            }
        }
    }
}