一道面试题

　　给定一个字符串的集合，格式如：{aaabbbccc}，{bbbddd}，{eeefff}，{ggg}，{dddhhh}要求将其中交集不为空的集合合并，要求合并完成后的集合之间无交集，例如上例应输出{aaabbbcccdddhhh}，{eeefff}，{ggg}。
　　（1）请描述你解决这个问题的思路；
　　（2）请给出主要的处理流程，算法，以及算法的复杂度
　　（3）请描述可能的改进。
回答：
　　集合使用hash_set来表示，这样合并时间复杂度比较低。
　　1、给每个集合编号为0，1，2，3...
　　2、创建一个hash_map，key为字符串，value为一个链表，链表节点为字符串所在集合的编号。遍历所有的集合，将字符串和对应的集合编号插入到hash_map中去。
　　3、创建一个长度等于集合个数的int数组，表示集合间的合并关系。例如，下标为5的元素值为3，表示将下标为5的集合合并到下标为3的集合中去。开始时将所有值都初始化为-1，表示集合间没有互相合并。在集合合并的过程中，我们将所有的字符串都合并到编号较小的集合中去。
　  遍历第二步中生成的hash_map，对于每个value中的链表，首先找到最小的集合编号（有些集合已经被合并过，需要顺着合并关系数组找到合并后的集合编号），然后将链表中所有编号的集合都合并到编号最小的集合中（通过更改合并关系数组）。
　　4、现在合并关系数组中值为-1的集合即为最终的集合，它的元素来源于所有直接或间接指向它的集合。
　　算法的复杂度为O(n)，其中n为所有集合中的元素个数。

package test;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashSet;
import java.util.Iterator;
import java.util.TreeMap;
import java.util.Vector;

public class StringSet {
public static int findRoot(int [] arr,int index){
while(arr[index]>=0){
index=arr[index];
}
return index;
}
public static HashSet<String> mergeSet(HashSet<String> hashSet1,HashSet<String> hashSet2){
Iterator<String> iterator=hashSet2.iterator();
while(iterator.hasNext()){
String string=iterator.next();
if(!hashSet1.contains(string)){
hashSet1.add(string);
}
}
return hashSet1;
}
public static void printSet(HashSet<String> hashSet){
Iterator<String> iterator=hashSet.iterator();
System.out.print("[ ");
while(iterator.hasNext()){
String  string=iterator.next();
System.out.print(string+" ,");
}
System.out.println(" ]");
}
public static void main(String[] args) throws FileNotFoundException {
TreeMap<Integer, HashSet<String>> hashMap=new TreeMap<Integer, HashSet<String>>();
BufferedReader br=new BufferedReader(new FileReader(new File("E:\\input.txt")));
HashSet<String> hashSet=null;
TreeMap<String, Vector<Integer>> hm=new TreeMap<String, Vector<Integer>>();
String line=null;
int nindex=0;
try {
while((line=br.readLine())!=null){
String[] str=line.split(" ");
hashSet=new HashSet<String>();
for(int i=0;i<str.length;i++){
System.out.print(str[i]+" ");
if(!hm.containsKey(str[i])){
Vector<Integer> v=new Vector<Integer>();
v.add(nindex);
hm.put(str[i], v);
}else{
hm.get(str[i]).add(nindex);
}
hashSet.add(str[i]);
}
System.out.println();
hashMap.put(nindex++, hashSet);
}
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("合并后--------------------------------------------------");
int k=nindex;
int []flag=new int[k];
for(int i=0;i<k;i++){
flag[i]=-1;
}
Iterator<String> it=hm.keySet().iterator();
while (it.hasNext()) {
String s=it.next();
Vector<Integer> vv=hm.get(s);
if(vv.size()>1){
int root=findRoot(flag, vv.get(0));
for(int p=1;p<vv.size();p++){
flag[vv.get(p)]=root;
}
}
}
int resSetNum=0;
for(int j=0;j<k;j++){
if(flag[j]==-1){
resSetNum++;
}
}
for(int j=0;j<k;j++){
if(flag[j]!=-1){
mergeSet(hashMap.get(flag[j]), hashMap.get(j));
hashMap.remove(j);
}
}
Iterator<Integer> its=hashMap.keySet().iterator();
while(its.hasNext()){
int key=its.next();
printSet(hashMap.get(key));
}
}

}