一道面试题

给定一个字符串的集合，格式如：{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));
 }
 }
 
 }