49. Group Anagrams

一、题目

　　1、审题

　　

　　2、分析：

　　　　给出一个字符串数组，将其中字符串中所含字母相同仅仅顺序不同的字符串归为一类，记录所有分类。

二、解答

　　1、思路：

　　　　方法一、利用 Java 封装的方法进行实现：

　　　　　　　　①、将字符串元素转为字符数组，进行排序，后重新转为有序的字符串；

　　　　　　　　②、新建一个 Map<String, List<String>>，用于存放分类，其中 Key 为 排序后的字符串，List 存放原字符串；

　　　　　　　　③、最终将②的 Map 的 ValueSet 返回即可。

public List<List<String>> groupAnagrams(String[] strs) {
        
        List<List<String>> resultList = new ArrayList<List<String>>();
        
        if(strs == null || strs.length == 0)
            return    resultList;
        
        int len = strs.length;
        char[][] chars = new char[len][];
        
        Map<String, ArrayList<String>> map = new HashMap<String, ArrayList<String>>();
        for (int i = 0; i < strs.length; i++) {　　
            chars[i] = strs[i].toCharArray();　　　　// 字符排序
            Arrays.sort(chars[i]);
            String sortedString = String.valueOf(chars[i]);

            if(map.containsKey(sortedString)) {　　　　// 存入 Map
                map.get(sortedString).add(strs[i]);
            }
            else {
                ArrayList<String> list = new ArrayList<String>();
                list.add(strs[i]);
                map.put(sortedString, list);
            }
        }
        
        for(ArrayList<String> list: map.values()) {　　// 放入 集合
            Collections.sort(list);
            resultList.add(list);
        }
        
        return resultList;
    }

　　简化版：

　　

public List<List<String>> groupAnagrams(String[] strs) {
        
        Map<String, List<String>> map = new HashMap<String, List<String>>();
        if(strs == null || strs.length < 1)
            return null;
        
        for(String str: strs) {
            
            // sort the str
            char[] cArray = str.toCharArray();
            Arrays.sort(cArray);
            String sortedStr = String.valueOf(cArray);
            
            // put str into the map
            if(!map.containsKey(sortedStr)) {
                map.put(sortedStr, new ArrayList<String>());
            }
            map.get(sortedStr).add(str);
        }
        
        // sort the list
        return new ArrayList<List<String>>(map.values());
    }

　　方法二：利用素数相乘来作为唯一可以确定的 Key ，免去了排序。

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        int[] prime = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 41, 43, 47, 53, 
                            59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103};//最多10609个z
        
        List<List<String>> resultList = new ArrayList<List<String>>();    // 
        
        // key = 唯一键值， value = resultList 中的 Key 的下标；
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();    
        
        for (String s : strs) {
            int key = 1;
            for (char c : s.toCharArray()) {// 获得唯一Key
                key *= prime[c - 'a'];
            }
            
            List<String> targetList;
            if (map.containsKey(key)) {
                targetList = resultList.get(map.get(key));
            } else {
                targetList = new ArrayList<String>();
                resultList.add(targetList);
                map.put(key, resultList.size() - 1);
            }
            targetList.add(s);
        }
        return resultList;
    }
}