Leetcode 49. 字母异位词分组

49. 字母异位词分组

给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。

示例:

输入: ["eat", "tea", "tan", "ate", "nat", "bat"]
输出:
[
  ["ate","eat","tea"],
  ["nat","tan"],
  ["bat"]
]

说明：

所有输入均为小写字母。
不考虑答案输出的顺序。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/group-anagrams
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

这道题的意思其实是这样的，就是在一个List中，将构成str的每个字符串元素都相同的str存放到一个List中，然后再将这些List存放到一个大的List中。

那么如何来判断所谓的“构成str的每个字符串元素都相同的str”呢？很简单，即组成一个str的各个字母个数都一样，即可认为是字母异位词，即是“构成str的每个字符串元素都相同的str”。那么问题便转化为了如何判断组成一个str的各个字母个数都一样，即在遍历str[]的时候，统计str[i]中每个一个字符出现的次数即可，再比较对应每个str[i]的字符出现次数数组是否都一样，若一样的话，即可认为该字母是异位词，然后把相应的异位词放到一个List里，最后遍历完的时候再放到一个大的List里面即可。

public List<List<String>> groupAnagrams(String[] strs) {
        List<List<String>> res = new ArrayList<>();
        int[][] p = new int[strs.length][26];
        for (int i = 0; i < strs.length; i++) {
            char[] dic = strs[i].toCharArray();
            for (int j = 0; j < dic.length; j++) {
                p[i][strs[i].charAt(j)-97] += 1;
            }
        }
        HashMap<Integer, StringBuilder> map = new HashMap<>();
        int j = 0;
        for (int i = 0; i < strs.length; i++) {
            StringBuilder sb = new StringBuilder();
            for (int k = 0;k < p[i].length; k++){
                sb.append(p[i][k]);
            }
            if (!map.containsValue(sb)) {
                map.put(j++, sb);
            }
        }
        for (StringBuilder v : map.values()) {
            List<String> tmp = new ArrayList<>();
            for (int i = 0; i < strs.length; i++) {
                StringBuilder t = new StringBuilder();
                for (int k = 0;k < p[i].length; k++){
                    t.append(p[i][k]);
                }
                if(t.toString().equals(v.toString()))
                    tmp.add(strs[i]);
            }
            if (res.contains(tmp))
                continue;
            res.add(tmp);
        }
        return res;
    }

这么做虽然行得通，但是笔者发现，这么写的复杂度未免也太高了，其中更是达到，很明显需要优化。

这种做法的复杂度主要高在读取字符数组，再写字符数组，再取字符数组，再比对字符数组。。。这一系列过程确实太过繁琐，这个过程需要优化。究其缘由，发现主要是在一开始的HashMap的设定上，笔者设定的是HashMap<Integer,StringBuilder>，事实上当时笔者的思路是有问题的，应该设定的是HashMap<StringBuilder,List<String>>，因为这样的话就可以将符合同样的次数模式的str[i]给直接加到List里面了。

public List<List<String>> groupAnagrams(String[] strs) {
        List<List<String>> res = new ArrayList<>();
        HashMap<String, List<String>> map = new HashMap<>();
        for (int i = 0 ;i < strs.length;i++){
            int[] dic = new int[26];
            Arrays.fill(dic,0);
            List<String> tmp = new ArrayList<>();
            for (int j = 0; j < strs[i].toCharArray().length;j ++){
                dic[strs[i].toCharArray()[j] - 97]+=1;
            }
            StringBuilder sb = new StringBuilder();
            for (int j = 0; j < 26; j++) {
                sb.append(dic[j]);
            }
            if (map.containsKey(sb.toString())) {
                map.get(sb.toString()).add(strs[i]);
            }
            else {
                tmp.add(strs[i]);
                map.put(sb.toString(), tmp);
            }

        }
        for(List<String> s:map.values())
            res.add(s);
        return res;
    }

进而当笔者在写出如上解法之后，又回顾了一下一开始并发现其实我们要找的是“构成str的每个字符串元素都相同的str”的时候，觉得应该还是有优化空间的。不过笔者过于鲁钝，还是没想到优化空间，经一好友提醒，才想到所谓的“构成str的每个字符串元素都相同的str”的等价说法，不愧是咸咸，一语惊醒梦中人。

“构成str的每个字符串元素都相同的str”，事实上，我们在统计这个数组的时候，我们都是用xx[char]来统计一个char的出现次数的，因为char在Java中是以整形的数字存储的，所以在统计出现字母的时候，就相当于以xx[int]形式来存储，而根据ASCII码表，字母都是按字母表来的，即“构成str的每个字符串元素都相同的str”在对每个str[i]排过序之后应该是一样的。所以我们只需要将str[i]的字符数组排序再转化成字符串，再存到HashMap里面，同时在containsKey()的时候只要修改对应的value就可以了（可以取出来直接add），这样既可优化不少。

public List<List<String>> groupAnagrams(String[] strs) {
        List<List<String>> res = new ArrayList<>();
        HashMap<String, List<String>> map = new HashMap<>();
        for (int i = 0 ;i < strs.length;i++){
            List<String> tmp = new ArrayList<>();
            StringBuilder sb = new StringBuilder();
            char[] t = strs[i].toCharArray();
            Arrays.sort(t);
            String key = Arrays.toString(t);
            if (map.containsKey(key)) {
                map.get(key).add(strs[i]);
            }
            else {
                tmp.add(strs[i]);
                map.put(key, tmp);
            }
        }
        for(List<String> s:map.values())
            res.add(s);
        return res;
    }

和咸咸打卡的第二天 √