LeetCode Top 100 Liked Questions 49. Group Anagrams (Java版； Medium)

welcome to my blog

LeetCode Top 100 Liked Questions 49. Group Anagrams (Java版; Medium)

题目描述

Given an array of strings, group anagrams together.

Example:

Input: ["eat", "tea", "tan", "ate", "nat", "bat"],
Output:
[
  ["ate","eat","tea"],
  ["nat","tan"],
  ["bat"]
]
Note:

All inputs will be in lowercase.
The order of your output does not matter.

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        List<List<String>> list = new ArrayList<>();
        int n = strs.length; 
        if(n==0){
            return list;
        }
        HashMap<String, List<String>> map = new HashMap<>();
        for(String str : strs){
            StringBuilder sb = new StringBuilder();
            int[] count = new int[26];
            for(char ch : str.toCharArray()){
                int i = ch - 'a';
                count[i]++;
            }
            for(int a : count){
                sb.append(a).append("#");
            }
            String s = sb.toString();
            if(!map.containsKey(s)){
                map.put(s, new ArrayList<String>());
            }
            map.get(s).add(str);
        }
        list.addAll(map.values());
        return list;
    }
}

第一次做, 对字符串排序时间复杂度是KlogK, 遍历一遍字符串统计字符次数的时间复杂度是K, 所以采用遍历的方式在字符串特别长的时候是更快的

/*
对每个字符排序需要KlogK时间复杂度, 其实不用排序, 直接遍历字符串, 统计各个字符出现的次数, 需要K时间复杂度, 出现次数相等的就是字母异位词
*/
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        List<List<String>> res = new ArrayList<>();
        if(strs==null || strs.length==0)
            return res;
        //
        HashMap<String, ArrayList<String>> hm = new HashMap<>();
        int[] arr =new int[26];
        for(int i=0; i<strs.length; i++){
            //每次循环后将计数数组的内容清空
            Arrays.fill(arr, 0);
            char[] ch = strs[i].toCharArray();
            for(int j=0; j<ch.length; j++){
                arr[ch[j]-'a']++;
            }
            //将统计的次数转成字符串, 并用#间隔每个次数, 防止混乱
            StringBuilder sb = new StringBuilder();
            for(int j=0; j<arr.length; j++)
                sb.append(arr[j]).append("#");
            String curr = sb.toString();
            if(!hm.containsKey(curr))
                hm.put(curr, new ArrayList<String>());
            hm.get(curr).add(strs[i]);
        }
        //保存结果
        //下面几句可以替换成一句return new ArrayList(hm.values());
        for(Map.Entry<String, ArrayList<String>> entry : hm.entrySet()){
            res.add(entry.getValue());
        }
        return res;
    }
}

第一次做, 对每个字符串按字典序排序, 相同的话就是字母异位词; 夯实java基础, 掌握HashMap的遍历方式entrySet(); 掌握 return new ArrayList(hm.values());

/*
最直接的想法就是对每个字符串按字典序排序, 排序后相同的两个字符串说明是字母异位词
哈希表的键存排序后的字符串, 哈希表的value存排序前的字符串
*/
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        List<List<String>> res = new ArrayList<>();
        if(strs==null || strs.length==0)
            return res;
        //
        HashMap<String, ArrayList<String>> hm = new HashMap<>();
        for(String s : strs){
            char[] ch = s.toCharArray();
            Arrays.sort(ch);
            String curr = String.valueOf(ch);
            if(!hm.containsKey(curr))
                hm.put(curr, new ArrayList<String>());
            hm.get(curr).add(s);
        }
        //下面这几句可以替换成一句 return new ArrayList(hm.values());
        for(Map.Entry<String, ArrayList<String>> entry : hm.entrySet()){
            res.add(entry.getValue());
        }
        return res;
    }
}