厚积薄发打卡Day100：哈希表（五）＜变位词组＞

变位词组

给定一组单词，请将它们按照变位词分组。

例如，输入一组单词[“eat”,“tea”,“tan”,“ate”,“nat”,“bat”]，这组单词可以分成3组，分别是[“eat”,“tea”,“ate”]、[“tan”,“nat”]和[“bat”]。

假设单词中只包含英文小写字母。

思路1：数字映射

题目中假设单词中只包含英文小写字母，因此可以创建数组来保存每个词组的单词：

1. 用质数映射到对应的26个单词
2. 用乘法运算保证每个词组拥有单词成分的唯一性
3. 最后用词组内的每个单词的映射质数乘积当key，value为同一乘积的词组list

那要用到质数，就得先找出26个质数：

@Test
public void find26PrimeNumber() {
    int[] arr = new int[26];
    int num = 0;
    //从2开始找质数
    for (int i = 2; i < 200; i++) {
        boolean flag = true;
        //不被j整除的数为质数
        for (int j = 2; j < i; j++) {
            if (i % j == 0) {
                flag = false;
                break;
            }
        }
        if (flag) {
            arr[num++] = i;
            if (num == arr.length) {
                break;
            }
        }
    }
    System.out.println(Arrays.toString(arr));
}
//得到结果：
//[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101]

实现

public class AnagramGroupWithPrime {

    public static List<List<String>> groupAnagrams(String[] strs) {
        //创建26个字母的数字映射
        int[] hash = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101};
        Map<Long, List<String>> group = new HashMap<>();
        for (String string : strs) {
            long wordHash = 1;
            for (int i = 0; i < string.length(); i++) {
                //遍历String的每个char，计算key存入value
                wordHash *= hash[string.charAt(i) - 'a'];
            }
            group.putIfAbsent(wordHash,new LinkedList<String>());
            group.get(wordHash).add(string);
        }
        return new LinkedList<>(group.values());
    }
}

put与putIfAbsent：以HashMap为例：

• put在放入数据时，如果放入数据的key已经存在与Map中，最后放入的数据会覆盖之前存在的数据

  

• putIfAbsent在放入数据时，如果存在重复的key，那么putIfAbsent不会放入值

  

• 不然在此题中一直都是空的链表了

验证

1. 正常试验：

   public static void main(String[] args) {
       String[] strings = {"eat","tea","tan","ate","nat","bat"};
       List<List<String>> lists = groupAnagrams(strings);
       System.out.println(lists);
   }
   

   此时group内容为：

   

   成功：

   

2. 溢出实验：因为使用了乘法，过程中可能会造成栈溢出的问题

   @Test
   public void testOverflow(){
       String[] strings2 = {"pneumonoultramicroscopicsilicovolcanoconiosis","pneumonoultramicroscopicsilicovolcanoconiossi","pneumonoultramicroscopicsilicovolcanoconio321","pneumonoultramicroscopicsilicovolcanoconio123"};
       List<List<String>> lists2 = groupAnagrams(strings2);
       System.out.println(lists2);
   }
   

   

   debug发现：就在第42个字母的时候已经顶不住了

   

思路2：字母排序

那既然变位词组，那么里面所有的单词都是一样的，那我直接用排序后的顺序作为key不就可以了？

如：【“eat”,“tea”,“ate”】的三个字母a、e、t升序排序后肯定为：aet；

实现

public class AnagramGroupWithSortChar {

    public static List<List<String>> groupAnagrams(String[] strings) {
        Map<String, List<String>> groups = new HashMap<>();
        for (String string : strings) {
            char[] chars = string.toCharArray();
            Arrays.sort(chars);
            String sortedStr = new String(chars);

            groups.putIfAbsent(sortedStr,new LinkedList<String>());
            groups.get(sortedStr).add(string);
        }
        return new LinkedList<>(groups.values());
    }
}

验证

1. 常规验证：

   public static void main(String[] args) {
       String[] strings = {"eat","tea","tan","ate","nat","bat"};
       List<List<String>> lists = groupAnagrams(strings);
       System.out.println(lists);
   }
   

   此时groupAnagrams的group为：

   

   结果：

   

2. 溢出验证：测试代码同思路1（不粘贴了）

   这波直接难以言喻：

   

   成功：