1: class DisjointSetProblem {

   2:     private final int SIZE = 7;

   3:     private int[] father;  

   4:     private static List<Set<String>> resultList = new ArrayList<Set<String>>();

   5:  

   6:     public static void main(String[] args) {

   7:         String[] str0 = { "aaa", "bbb", "ccc", };

   8:         String[] str1 = { "bbb", "ddd", };

   9:         String[] str2 = { "eee", "fff", };

  10:         String[] str3 = { "ggg", };

  11:         String[] str4 = { "ddd", "hhh", };

  12:         String[] str5 = { "xx", "yy", };

  13:         String[] str6 = { "zz", "yy", };

  14:         String[][] strs = { str0, str1, str2, str3, str4, str5, str6 };

  15:         //change String[][] to List<Set>  

  16:         for (String[] str : strs) {

  17:             //when I write--"Arraylist list=Arrays.asList(strArray)","addAll()" is unsupported for such a arraylist.  

  18:             Set<String> set = new HashSet<String>();

  19:             set.addAll(Arrays.asList(str));

  20:             resultList.add(set);

  21:         }

  22:         DisjointSetProblem disjointSet = new DisjointSetProblem();

  23:         disjointSet.disjoin(strs);

  24:     }

  25:  

  26:     /*

  27:      * 获取hashmap过程

  28:      * */

  29:     public void disjoin(String[][] strings) {

  30:         if (strings == null || strings.length < 2)

  31:             return;

  32:         initial();

  33:         // 获得hash_map：key为字符串，value为一个链表

  34:         Map<String, List<Integer>> map = storeInHashMap(strings);

  35:         // 并查集进行合并

  36:         union(map);

  37:     }

  38:  

  39:     //in the beginning,each element is in its own "group".  

  40:     public void initial() {

  41:         father = new int[SIZE];

  42:         for (int i = 0; i < SIZE; i++) {

  43:             father[i] = i;

  44:         }

  45:     }

  46:  

  47:     /* Map<k,v> 

  48:      * key:String 

  49:      * value:List<Integer>-in which sets the string shows up. 

  50:      */

  51:     public Map<String, List<Integer>> storeInHashMap(String[][] strings) {

  52:         Map<String, List<Integer>> map = new HashMap<String, List<Integer>>();

  53:         for (int i = 0; i < SIZE; i++) {

  54:             for (String each : strings[i]) {

  55:                 if (!map.containsKey(each)) {

  56:                     List<Integer> list = new ArrayList<Integer>();

  57:                     list.add(i);

  58:                     map.put(each, list);

  59:                 } else {

  60:                     map.get(each).add(i);

  61:                 }

  62:             }

  63:         }

  64:  

  65:         // 打印出map

  66:         System.out.println("集合映射所生成的hashmap为：");

  67:         printMap(map);

  68:         return map;

  69:     }

  70:  

  71:     private void printMap(Map<String, List<Integer>> map) {

  72:         // TODO Auto-generated method stub

  73:         Iterator<Map.Entry<String, List<Integer>>> iter = map.entrySet()

  74:                 .iterator();

  75:         while (iter.hasNext()) {

  76:             Map.Entry<String, List<Integer>> entry = iter.next();

  77:             String key = entry.getKey();

  78:             List<Integer> value = entry.getValue();

  79:             System.out.println(key + ":" + value);

  80:         }

  81:         System.out.println();

  82:     }

  83:  

  84:     /*

  85:      * 对hashmap进行并查集合并操作

  86:      * */

  87:     public void union(Map<String, List<Integer>> map) {

  88:         Iterator<Map.Entry<String, List<Integer>>> it = map.entrySet()

  89:                 .iterator();

  90:         while (it.hasNext()) {

  91:             Map.Entry<String, List<Integer>> entry = it.next();

  92:             List<Integer> value = entry.getValue();

  93:             unionHelp(value);//the arrays whose indexes are in the same list should be merged to one set.             

  94:         }

  95:         // 打印出father父节点信息

  96:         System.out.println("hashmap集合合并之后的父节点信息为：");

  97:         printFather(father);//System.out.println("the father array is " + Arrays.toString(father));

  98:         printSetList(resultList);

  99:         //merge two sets  

 100:         for (int i = 0; i < SIZE; i++) {

 101:             if (i != father[i]) {

 102:                 // set：无重复元素

 103:                 Set<String> dest = resultList.get(father[i]);

 104:                 Set<String> source = resultList.get(i);

 105:                 dest.addAll(source);

 106:             }

 107:         }

 108:         //clear a set which has been added.  

 109:         // 当B集合添加到A集合后，清空B集合

 110:         for (int i = 0; i < SIZE; i++) {

 111:             if (i != father[i]) {

 112:                 resultList.get(i).clear();

 113:             }

 114:         }

 115:         System.out.println("合并后:" + resultList);

 116:     }

 117:  

 118:     public void unionHelp(List<Integer> list) {

 119:         int minFather = getFather(list.get(0));//list[0] is the smaller.  

 120:         // 传过来的list参数已经排好序

 121:         for (int i = 0, size = list.size(); i < size; i++) {

 122:             //father[list.get(i)] = minFather;

 123:             unionHelp(list.get(0),list.get(i));

 124:         }

 125:     }

 126:  

 127:     // 路径压缩

 128:     public int getFather(int x) {

 129:         while (x != father[x]) {

 130:             x = father[x];

 131:         }

 132:         return x;

 133:     }    

 134:  

 135:     private void printFather(int[] fatherNode) {

 136:         // TODO Auto-generated method stub

 137:         for (int node : fatherNode)

 138:             System.out.print(node + " ");

 139:         System.out.println();

 140:     }

 141:  

 142:     private void printSetList(List<Set<String>> list) {

 143:         // TODO Auto-generated method stub

 144:         System.out.print("合并前:");

 145:         for (int i = 0; i < SIZE; i++) {

 146:             System.out.print(list.get(i) + " ");

 147:         }

 148:         System.out.println();

 149:     }

 150:  

 151:     //general union in disjoin set.But we overload it in this case.  

 152:     public void unionHelp(int x, int y) {

 153:         if (father[x] != father[y]) {

 154:             int fx = getFather(x);

 155:             int fy = getFather(y);

 156:             //merge two arrays to the array that has a smaller index.  

 157:             if (fx < fy) {

 158:                 father[y] = fx;

 159:             } else {

 160:                 father[x] = fy;

 161:             }

 162:         }

 163:     }

 164:     

 165: }