day2 leetcode-hot100-2

49. 字母异位词分组 - 力扣（LeetCode）

49. 字母异位词分组 - 力扣（LeetCode）没想到第二、三天打卡就g了（上课+导师催改论文），希望以后顺利打卡。

小菜鸡的我只会暴力：

        暴力具体过程：

        （1）从第一个字符串开始遍历，遇到符合字母异位的就加入ArrayList。

        （2）需要注意设置一个标记数组flag[n]，防止重复问题。

        （3）判断函数的写法：我是简单的计算值（存在逻辑问题）或排序。

复习到的基础知识（deepseek老师）：

        （1）列表初始化：List<List<String>> res = new ArrayList<>;

        （2）字符串转换字符数组：char[] chars_a = a.toCharArray();

        （3）字符数组转字符串：String str = new String(c);
        （4）字符升序排序，会改变原来的：Arrays.sort(chars_a);

        （5）字符转换为数值：int value =(int) str.charAt(i);

        （6）引用数据用函数length(),其他的为属性.length;

        （7）获取新建：ArrayList<String> list =map.getOrDefault(key,new ArrayList<String>());

        （8）添加整个集合list.addAll(整个集合)

        （9）遍历hashmap

        map.forEach((key,value)->{
            ans.add(value);
        });

第一版暴力（但逻辑也存在错误）

• 例如 "ac" 和 "bb" 的 ASCII 和相同（97+99 = 98+98），但不是字母异位词。

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        int[] flag=new int[strs.length];
        List<List<String>> res=new  ArrayList<>();
        for(int i=0;i<strs.length;i++){
            if(flag[i]==1){
                continue;
            }
            else{
                flag[i]=1;
                List<String> res1 = new ArrayList<>();
                res1.add(strs[i]);
                for(int j=i+1;j<strs.length;j++){
                    if(isdiff(strs[i],strs[j]) && flag[j]==0){
                        res1.add(strs[j]);
                        flag[j]=1;
                    }
                }
                res.add(res1);
            }
            
        }
        return res;
        
    }
    public boolean isdiff(String a,String b){
        if(a.length()!=b.length()){
            return false;
        }
        else{
            int value_a=0;
            int value_b=0;
            for(int i=0;i<a.length();i++){
                value_a+=(int)a.charAt(i);
                value_b+=(int)b.charAt(i);
            }
            if(value_a==value_b){
                return true;
            }
            else{
                return false;
            }
        }

    }
}

第二版暴力（但逻辑正确，但复杂度太高了）

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        int[] flag=new int[strs.length];
        List<List<String>> res=new  ArrayList<>();
        for(int i=0;i<strs.length;i++){
            if(flag[i]==1){
                continue;
            }
            else{
                flag[i]=1;
                List<String> res1 = new ArrayList<>();
                
                res1.add(strs[i]);
                for(int j=i+1;j<strs.length;j++){
                    if(isdiff(strs[i],strs[j]) && flag[j]==0){
                        res1.add(strs[j]);
                        flag[j]=1;
                    }
                }
                res.add(res1);
            }
            
        }
        return res;
        
    }
    public boolean isdiff(String a,String b){

        if(a.length()!=b.length()){
            return false;
        }
        else{
            boolean flag=true;
            char[] chars_a = a.toCharArray();
            char[] chars_b = b.toCharArray();
            Arrays.sort(chars_a);
            Arrays.sort(chars_b);
            for(int i=0;i<a.length();i++){
                if(chars_a[i]!=chars_b[i]){
                    return false;
                }

            }
        }
        return true;

    }
}

3.hashmap的方法+排序O(nklogk)

        利用哈希表查询的时间复杂度O(1)的优点

        难点在于构造HashMap<String,ArrayList<String>>;

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

4.hashmap+计数O(n(k+$))

计数简单来说就是计算每个str中各个字母的个数，异位词的特点都是计数值一样，所有可用哈希表。

复习到的知识点：

        （1）char-char是整形

        （2）(char)(chat+int)转化为字符

        （3）StringBuffer在字符串相加方面是真的好用。

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        List<List<String>> ans = new ArrayList<>();
        HashMap<String,ArrayList<String>> map =new HashMap<>();
        for(String str:strs){
            int[] count = new int[26];
            for(int i=0;i<str.length();i++){
                count[str.charAt(i)-'a']++;

            }
            StringBuffer sb =new StringBuffer();
            for(int i=0;i<count.length;i++){
                if(count[i]!=0){
                    sb.append((char)('a'+i));
                    sb.append(count[i]);
                }
            }
            String key = sb.toString();
            ArrayList<String> list = map.getOrDefault(key,new ArrayList<String>());
            list.add(str);
            map.put(key,list);
            

        }
        ans.addAll(map.values());
        return ans;
    }
}