Letcode每日一题-字母异位词分组

题目描述如下:

     是否位字母异位词的判定标准是是否具有相同的字符，如何判断两个字符串具有相同的字符，一种方法是循环

遍历，如果具有相同的字符则把对应的字符删除，依次循环，最后判断作为基准的字符串是否为空即可，这种比

较麻烦，而且 效率太低。

     另外一种办法是对这些字符进行排序，则排序后的两个字符串相同，则为字母异位词。

     在这里题目中说所有输入均为 小写字母，则还有一种方法就是用一个长度位26的数组存储各个字母出现的字数，

最后根据这个数组拼接字符串，如果拼接后的字符串的字符串相同则为字母异位词。

排序实现:

public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<String, List<String>>();
        for (String str : strs) {
            char[] array = str.toCharArray();
            Arrays.sort(array);
            String key = new String(array);
            List<String> list = map.getOrDefault(key, new ArrayList<String>());
            list.add(str);
            map.put(key, list);
        }
        return new ArrayList<List<String>>(map.values());
    }

复杂度分析

时间复杂度：O(nklogk)，其中 n 是 strs 中的字符串的数量，k 是 strs 中的字符串的的最大长度。需要遍历 n 个

字符串，对于每个字符串，需要 O(klogk) 的时间进行排序以及 O(1)的时间更新哈希表，因此总时间复杂度是

O(nklogk)。

空间复杂度：O(nk)，其中 n 是strs 中的字符串的数量，k 是 strs 中的字符串的的最大长度。需要

用哈希表存储全部字符串。

 

利用26长度的数组实现：

public List<List<String>> groupAnagrams(String[] strs) {
        HashMap<String,List<String>> result=new HashMap<>();
        for(int i=0;i<strs.length;i++){
            int[] charsCount=new int[26];
            for(int j=0;j<strs[i].length();j++){
                charsCount[strs[i].charAt(j)-'a']++;
            }
            StringBuilder key=new StringBuilder();
            for(int j=0;j<charsCount.length;j++){
                if(charsCount[j]==0){
                    continue;
                }
                char tmp=(char)(j+'a');
                for(int z=0;z<charsCount[j];z++){
                    key.append(tmp);
                }
            }
            if(result.get(key.toString())==null){
                result.put(key.toString(),new ArrayList<>());
            }
            result.get(key.toString()).add(strs[i]);
        }
        ArrayList<List<String>> realResult=new ArrayList<>(result.size());
        for(List<String> value:result.values()){
            realResult.add(value);
        }
        return realResult;
    }

时间复杂度：O(n(k+∣Σ∣))，其中 n 是 strs 中的字符串的数量，k 是 strs 中的字符串的的最大长度，Σ 是字

符集，在本题中字符集为所有小写字母，Σ∣=26。需要遍历 n 个字符串，对于每个字符串，需要 O(k) 的时

间计算每个字母出现的次数，O(∣Σ∣) 的时间生成哈希表的键，以及 O(1) 的时间更新哈希表，因此总时间

复杂度是 O(n(k+∣Σ∣))。

空间复杂度：O(n(k+∣Σ∣))，其中 nn 是 strs 中的字符串的数量，k是 strs 中的字符串的最大长度，Σ 是字

符集，在本题中字符集为所有小写字母，∣Σ∣=26。需要用哈希表存储全部字符串，而记录每个字符串中

每个字母出现次数的数组需要的空间为 O(∣Σ∣)，在渐进意义下小于 O(n(k+∣Σ∣))，可以忽略不计。

总结

就最后的运行表现来说排序的方法会更快一点