49. Group Anagrams [Medium]

为应该分为同一组的str找到一个统一标识，作为HashMap的key，key对应的value是一个List

map.values()就是结果的Collections形式，new ArrayList(map.values())就得到List形式的结果

本题各个解答最大的区别：统一标识的确定

最容易想到的是将每个字符串中的字符排序，形成的新字符串，但这样时间复杂度O(nlogn)

最后一段巧妙利用了字符只有26个且连续，用一个数组记录每个字符出现多少次，作为标识，将时间复杂度降至O(n)

/**
 * 自己的代码1
 * 用map记录每个字符集合对应的strs中字符串的list
 * 将每个字符串中的字符sort，得到的array转换为String，作为map的key
 * 时间复杂度O(nlogn)
 * Runtime: 11 ms, faster than 35.81% 
 * Memory Usage: 53.3 MB, less than 5.68%
 */
class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        HashMap<String, List> map = new HashMap();
        for (String str : strs) {
            char[] arr = str.toCharArray(); 
            Arrays.sort(arr);
            String sortedStr = String.valueOf(arr); // 或者用Arrays.toString(arr)，但效率很低
            if (map.containsKey(sortedStr)) {
                List l = map.get(sortedStr);
                l.add(str);
            } else {
                List l = new LinkedList<String>();
                l.add(str);
                map.put(sortedStr, l);
            }
        }
        
        return new ArrayList(map.values());
    }
}

/**
 * 自己的代码2，上一段的另一种写法，比上面精简但损失一点效率
 * 时间复杂度O(nlogn)
 * Runtime: 16 ms, faster than 26.14%
 * Memory Usage: 53.7 MB, less than 5.68% 
 */
class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        HashMap<String, List> map = new HashMap();
        for (String str : strs) {
            char[] arr = str.toCharArray();
            Arrays.sort(arr);
            String sortedStr = String.valueOf(arr);
            List l = map.getOrDefault(sortedStr, new LinkedList<String>());
            l.add(str);
            map.put(sortedStr, l);
        }
        return new ArrayList(map.values());
    }
}

/**
 * 上两段的另一种写法
 * 时间复杂度O(nlogn)
 * Runtime: 13 ms, faster than 32.79%
 * Memory Usage: 53.1 MB, less than 6.43%
 */
class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        HashMap<String, List> map = new HashMap();
        for (String str : strs) {
            char[] arr = str.toCharArray();
            Arrays.sort(arr);
            String sortedStr = String.valueOf(arr);
            if (!map.containsKey(sortedStr)) {
                map.put(sortedStr, new LinkedList());
            }
            map.get(sortedStr).add(str);
        }
        return new ArrayList(map.values());
    }
}

/**
 * 思路仍然差不多，但巧妙利用26个字母的ASCII相连的特性，不用sort每一个字符串中所有字符
 * 时间复杂度O(n)
 * Runtime: 11 ms, faster than 35.81%
 * Memory Usage: 53 MB, less than 7.02%
 */
class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        HashMap<String, List> map = new HashMap();
        for (String str : strs) {
            char[] arr = new char[26];
            for (char c : str.toCharArray()) {
                arr[c - 'a']++;
            }
            String sortedStr = String.valueOf(arr);
            if (!map.containsKey(sortedStr)) {
                map.put(sortedStr, new LinkedList());
            }
            map.get(sortedStr).add(str);
        }
        return new ArrayList(map.values());
    }
}