力扣49题：字母异位词分词（JAVA）

最新推荐文章于 2025-12-02 18:04:47 发布

原创最新推荐文章于 2025-12-02 18:04:47 发布 · 262 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #java #算法

题目描述：

给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。

字母异位词 是由重新排列源单词的所有字母得到的一个新单词。

思路：

1、在使用 HashMap 的基础上，判断两个字符串到底是不是属于字母异位词；
2、如果该字符串数组不为空，就在开始时把第一个字符串加入结果集合 List<List> result；
3、遍历字符串数组后面的所有字符串，与结果集合中的进行对比，如果相同就直接放入，不相同就开一个新的集合
放入 List< String> res；
4、根据力扣的结果测试用例逐步完善算法，比如 “” 的存在以及它的多次存在等；

下面附上我的代码：

IDEA可以跑出来的，带注解：

public class LC49_2_selfAC {
    public static void main(String[] args) {
        String[] strs = {"tea","","eat","","tla",""};
//        String[] strs = {"stop","pots","reed","","tops","deer","opts",""};
//        String[] strs = {"ddddddddddg","dgggggggggg"};
//        String[] strs = {"eat","tea","tan","ate","nat","bat"};
        List<List<String>> result = new ArrayList<>();
        HashMap<Character,Character> map = new HashMap<>();
        int n = strs.length;
        List<String> res = new ArrayList<>();
        // 考虑列表字符串到底是否空。首先把第一个字符串放进去，用后面的和它比；
        res.add(strs[0]);
        result.add(res);
        int flag = 0;
        int idex = 0;
        for (int i = 1; i < n; i++) {
            // 定位获取列表字符串的每一个字符串
            String str = strs[i];
            for (int j = 0; j < result.size(); j++) {
                // 如果相同，证明它们属于一个集合，装进去就行
                String mod = result.get(j).get(0);
                boolean isSame = makeSureSame(str,mod);
                // 细节：每个集合的都是一个相同的字符个数集合，所以只用取第一个来比较
                if(isSame){
                    result.get(j).add(str);
                    break;
                }else{
                    // 如果不相同，后续继续判断
                    // 在这里也细分了到底是不是最后一个集合
                    if(j == result.size()-1){
                        // 这是最后一个可以比较的集合
                        List<String> ress = new ArrayList<>();
                        if(str.equals("")){
                            ress.add("!1");
                            result.add(ress);
                            idex = result.size()-1;
                            flag = 1;
                        }else{
                            // 不是空字符串，前面已经对比出了不属于已有集合，所以直接加到一个新集合
                            ress.add(str);
                            result.add(ress);
                        }
                        break;
                    }
                    // 以下的试用于目前的判断还没走到结果集合的最后一个
                    else if(str=="" && flag == 0){
                        List<String> ress = new ArrayList<>();
                        // 这里把第一个字符串“”存了起来
                        ress.add("!2");
                        result.add(ress);
                        idex = result.size()-1;
                        flag = 1;
                        break;
                    }else if(str.equals("")){
                        //这里是字符串本身为空
                        result.get(idex).add("?3");
                        break;
                    }
                }
            }
        }

        for (int i = 0; i < result.size(); i++) {
            List<String> rest = result.get(i);
            for (int j = 0; j < rest.size(); j++) {
                System.out.print(rest.get(j)+"  ");
            }
            System.out.println();
        }
    }

    public static boolean makeSureSame(String s1,String s2){
        // 用hash存每个字母，先加进去字符和出现次数，再用另一个字符串的来检查，来减少次数，
        // 最终为 0 就表示相同
        // 其中要考虑一些条件
        boolean res = true;
        if(s1.length()!=s2.length()) return false;

        HashMap<Character,Integer> hashMap = new HashMap<>();
        for (int i = 0; i < s1.length(); i++) {
            if(hashMap.containsKey(s1.charAt(i))){
                int times = hashMap.get(s1.charAt(i));
                hashMap.put(s1.charAt(i),times+1);
            }else{
                hashMap.put(s1.charAt(i),1);
            }
        }

        for (int i = 0; i < s2.length(); i++) {
            if(hashMap.containsKey(s2.charAt(i))){
                int times = hashMap.get(s2.charAt(i));
                hashMap.put(s2.charAt(i),times-1);
                if(times-1 == 0){
                    hashMap.remove(s2.charAt(i));
                }
            }else{
                res = false;
                break;
            }
        }
        if(hashMap.isEmpty()){
            res = true;
        }else{
            res = false;
        }
        return res;
    }
}

下面是力扣可以通过的版本：

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        List<List<String>> result = new ArrayList<>();
        HashMap<Character,Character> map = new HashMap<>();
        int n = strs.length;
        if (strs.length == 0) return result;
        List<String> res = new ArrayList<>();
        res.add(strs[0]);
        result.add(res);
        int flagg = 0;
        int idex = 0;
        for (int i = 1; i < n; i++) {
            String str = strs[i];
            for (int j = 0; j < result.size(); j++) {
                String mod = result.get(j).get(0);
                boolean isSame = makeSureSame(str,mod);
                if(isSame){
                    result.get(j).add(str);
                    break;
                }else{
                    List<String> ress = new ArrayList<>();
                    if(j == result.size()-1){                    
                        if(str.equals("")){
                            ress.add("");
                            result.add(new ArrayList<>(ress));
                            idex = result.size()-1;
                            flagg = 1;
                        }else{
                            ress.add(str);
                            result.add(ress);
                        }
                        break;
                    }
                    else if(str.equals("") && flagg == 0){
                        ress.add("");
                        result.add(new ArrayList<>(ress));
                        idex = result.size()-1;
                        flagg = 1;
                        break;
                    }else if(str.equals("")){
                        result.get(idex).add("");
                        break;
                    }
                }
            }
        }
        return result;
    }

    public boolean makeSureSame(String s1,String s2){
        boolean res = true;
        if(s1.length()!=s2.length()) return false;

        HashMap<Character,Integer> hashMap = new HashMap<>();
        for (int i = 0; i < s1.length(); i++) {
            if(hashMap.containsKey(s1.charAt(i))){
                int times = hashMap.get(s1.charAt(i));
                hashMap.put(s1.charAt(i),times+1);
            }else{
                hashMap.put(s1.charAt(i),1);
            }

        }

        for (int i = 0; i < s2.length(); i++) {
            if(hashMap.containsKey(s2.charAt(i))){
                int times = hashMap.get(s2.charAt(i));
                hashMap.put(s2.charAt(i),times-1);
                if(times-1 == 0){
                    hashMap.remove(s2.charAt(i));
                }
            }else{
                res = false;
                break;
            }
        }
        if(hashMap.isEmpty()){
            res = true;
        }else{
            res = false;
        }

        return res;
    }
}