力扣49题:字母异位词分词(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;
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值