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

最新推荐文章于 2025-12-02 18:04:47 发布
原创 最新推荐文章于 2025-12-02 18:04:47 发布 · 262 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 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;
    }
}
浅滩_
关注
力扣：49.字母异位词分组
liulangcheshou的博客
08-14 366
数据库一般有两个术语： 1.数据库文件 指的是数据库数据保存的文件 2.数据库实例 指的是用于处理数据库文件的进程，mysql为单进程多线程模型。 mysql实例在操作系统中的表现就是一个实例。 Mysql的组成部分： 连接池组件 管理服务和工具组件 SQL接口组件 查询分析器组件 优化器组件 缓冲组件 插件式存储引擎 物理文件 ...
力扣hot 100：49. 字母异位词分组(python & C++)
qq_33489955的博客
05-27 1696
输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]这个方法用于将一组字符串按字母异位词（anagram）分组。该方法用于将一组字符串按字母异位词（anagram）分组。我们来详细跟踪代码执行的每一步，以理解它是如何处理输入。让我们详细跟踪代码执行的每一步，以理解它是如何处理输入。，将每个值（字符串列表）添加到。的类，类中包含一个名为。的类，类中包含一个名为。
力扣经典150题第四十二题：字母异位词分组
热门推荐
私聊前往站内信：https://i.youkuaiyun.com/#/msg/chat/weixin_44976692
04-25 1万+
本篇博客介绍了力扣经典150题中的第四十二题：字母异位词分组。题目要求将给定的字符串数组中的字母异位词分组，并返回分组结果。输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]，将其中字母异位词（由重新排列源单词的所有字母得到的新单词）组合在一起，最终返回分组后的结果列表。输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]的长度，k 是字符串的最大长度。展示了几个不同的示例测试，验证了字母异位词分组的功能。
《LeetCode力扣练习》第49题 字母异位词分组 Java
XRT_knives的博客
03-16 285
《LeetCode力扣练习》第49题 字母异位词分组 Java 一、资源 题目： 给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。 字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母通常恰好只用一次。 示例 1: 输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”] 输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]] 示例 2: 输入: strs =
力扣：49. 字母异位词分组（Python3）
欢迎光临
08-03 421
力扣：49. 字母异位词分组（Python3）
LeetCode第 49 题：字母异位词分组(C++)
zj
12-14 1780
49. 字母异位词分组 - 力扣（LeetCode） 核心问题在于如何（快速）判断字母异位词，很容易想到字符串匹配里面的RK算法，其实就是一种编码方式。最简单的可以将每个单词的每个字母的ascii码加起来，因为字母异位词加起来得到的和必然是相同的，但是单词太多就可能冲突：不是字母异位词加起来也可能相同，既然加不行，可以乘啊，而且不一定非要用一个整数来编码，用字符串也可以，排序就是字符串的思路。 排序 class Solution { public: vector<vector<stri
「力扣」第 49 题：字母异位词分组（哈希表）
李威威的博客
04-06 610
题目 难度 题解 49. 字母异位词分组 中等 自定义字符串的哈希规则，使用质数作为乘法因子（Java） 思路： 每个字符串其实对应一个 key，相同字母组合对应的 key 是相等的。这里考察了哈希函数。 Java 代码： import java.util.ArrayList; import java.util.HashMap; import java.util.List;...
力扣每日打卡17 49. 字母异位词分组 (中等)
2301_79369384的博客
04-22 2044
这是刷算法题的第十七天，用到的语言是JS 题目：力扣 49. 字母异位词分组 (中等)
力扣第四十九题——字母异位词分组
m0_74932528的博客
08-02 1162
哈希表（HashMap）是一种非常强大的数据结构，它在很多算法问题中都有广泛的应用。
力扣242.有效的字母异位词(Java语言，排序法、散列表法)
LNsupermali的博客
12-08 526
力扣242.有效的字母异位词(Java语言，排序法、散列表法)
力扣刷题：字母异位词分组（java实现）
谦谦均的博客
11-09 792
题目：给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。 字母异位词 是由重新排列源单词的字母得到的一个新单词，所有源单词中的字母都恰好只用一次。 示例 1: 输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"] 输出: [["bat"],["nat","tan"],["ate","eat","tea"]] 示例 2: 输入: strs = [""] 输出: [[""]] 示例 3: 输入: strs = ["a"] 输
【中等】力扣算法题解析LeetCode49：字母异位词分组
ylumwd的博客
07-19 418
题目要求将字母异位词分组（如"eat"和"tea"）。核心解法是利用哈希表，以排序后的字符串作为键，原字符串列表为值。步骤：1. 遍历字符串数组，对每个字符串排序生成统一键；2. 使用哈希表分组存储；3. 返回所有分组列表。Java实现通过Arrays.sort排序字符数组，并用computeIfAbsent简化哈希表操作。时间复杂度为O(n·mlogm)，其中n为字符串数量，m为字符串最大长度。示例代码已通过力扣测试，高效完成分组。
[ LeetCode ] 题刷刷(Python)-第49题：字母异位词分组
zhou_ge1的博客
04-10 615
给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。字母异位词是由重新排列源单词的所有字母得到的一个新单词。即将含有相同字符但排列顺序不同的字符串放入同一个组中。
力扣39题：组合总和的 Java 实现
2301_77695569的博客
07-24 958
通过本文的介绍，你应该已经了解了如何使用 Java 解决力扣第39题“组合总和”。这个问题是一个很好的练习回溯算法的机会。希望本文能够帮助你更好地理解和掌握回溯算法。如果你有任何问题或需要进一步的帮助，请随时在评论区提问。
力扣1971.寻找图中是否存在路径
2401_89332662的博客
11-30 693
本文研究了无向图中顶点连通性判断问题，针对大规模数据（顶点数达2×10^5）提出两种高效解法。并查集方法通过路径压缩和按秩合并优化，实现接近线性的时间复杂度；BFS方法通过邻接表存储和队列遍历确保高效性。实验表明两种方法均能有效处理大规模图数据，其中并查集在空间效率上更具优势。文章详细阐述了两种算法的实现细节，包括数据结构设计、核心操作流程和复杂度分析，为大规模图连通性问题提供了实用解决方案。
Leetcode 65 固定长度窗口 | 中心辐射型固定窗口
im_AMBER的博客
12-01 817
窗口是 “连续固定长度” 还是 “以某个点为中心辐射”？若题目说 “长度为 k 的子数组”→ 普通固定窗口；若题目说 “半径为 k”“以每个元素为中心”→ 中心辐射型窗口。结果是 “每个窗口对应一个值” 还是 “每个索引对应一个值”？前者→普通固定窗口；后者→中心辐射型窗口。
LeetCode面试HOT100—— 206. 反转链表
最新发布
xwhxy的博客
12-02 625
本文详细解析了反转单链表的迭代最优解（头插法）。该方法通过三个指针（pre、cur、nxt）实现，时间复杂度O(n)，空间复杂度O(1)。核心思路是将原链表节点逐个取出并插入新链表头部，最终返回pre指针指向的新链表头。文章通过逐行代码注释、分步演示（1→2→3→4→null示例）和关键细节分析，帮助读者彻底理解反转过程。特别强调了保存nxt指针的必要性和边界情况处理，总结为"保存下一个，反转当前，移动双指针"的操作口诀。
LeetCode 热题 100——二叉树——二叉树的层序遍历&将有序数组转换为二叉搜索树
weixin_53318497的博客
12-02 545
给你二叉树的根节点 root ，返回其节点值的 层序遍历。（即逐层地，从左到右访问所有节点）。示例 1：输入：root = [3,9,20,null,null,15,7]输出：[[3],[9,20],[15,7]]示例 2：输入：root = [1]输出：[[1]]示例 3：输入：root = []输出：[]提示：树中节点数目在范围 [0, 2000] 内。
LeetCode 230：二叉搜索树中第 K 小的元素 —— 从 Inorder 遍历到 Order Statistic Tree
六六哥的博客
12-02 741
preorder（根–左–右）得到的序列一般不是有序的，所以用 preorder 数到的第 k 个节点并不等于第 k 小的节点。Follow-up 问的是更偏「数据结构设计」的问题：如果这棵 BST 经常执行插入、删除，并且频繁查询第 k 小，用每次 inorder 从头数的方式就不够高效了，因为每次查询仍然可能接近 O(n)。利用 inorder 的有序性，一个直接的解法是：递归做 inorder 遍历，同时维护一个外部计数器 count，当访问到第 k 个节点时记录答案并提前结束遍历。
力扣100题字母异位词
08-23
在 LeetCode 上，第 100 题是“相同的树”（Same Tree），而“字母异位词分组”是 LeetCode 第 49 题[^1]。因此，可能存在对题号的混淆。下面将分别讨论这两道题的相关解法和背景。 ### 1. LeetCode 第 49 题：字母异位词分组（Group Anagrams） **题目描述** 给定一个字符串数组，将所有字母异位词（anagram）组合在一起。字母异位词是指由相同字母不同顺序构成的字符串。 **解法思路** 解决该问题的核心思想是：**字母异位词在排序后具有相同的字符串形式**。因此，可以利用哈希表（Map）来将相同排序后的字符串作为键，对应的原始字符串列表作为值。 #### Java 解法示例（排序 + 哈希表） ```java class Solution { public List<List<String>> groupAnagrams(String[] strs) { Map<String, List<String>> map = new HashMap<>(); for (String str : strs) { char[] arr = str.toCharArray(); Arrays.sort(arr); String key = new String(arr); List<String> list = map.getOrDefault(key, new ArrayList<>()); list.add(str); map.put(key, list); } return new ArrayList<>(map.values()); } } ``` #### Java 解法示例（计数 + 哈希表） 该方法适用于字符集较大的情况，例如 Unicode 字符。它基于字符出现的频率构建键值。 ```java public List<List<String>> groupAnagrams(String[] strs) { Map<String, List<String>> map = new HashMap<>(); for (String str : strs) { int[] count = new int[26]; for (char c : str.toCharArray()) { count[c - 'a']++; } StringBuilder key = new StringBuilder(); for (int i = 0; i < 26; i++) { key.append(count[i]).append('#'); } String keyStr = key.toString(); if (!map.containsKey(keyStr)) { map.put(keyStr, new ArrayList<>()); } map.get(keyStr).add(str); } return new ArrayList<>(map.values()); } ``` **时间复杂度分析** - 排序法：O(n * k log k)，其中 `n` 是字符串数量，`k` 是字符串的最大长度。 - 计数法：O(n * k)，其中 `k` 是字符串的平均长度，适用于较长字符串的情况。 **空间复杂度** - O(n * k)，用于存储哈希表中的键值对。 ### 2. LeetCode 第 100 题：相同的树（Same Tree） **题目描述** 给定两棵二叉树，判断它们是否相同。两棵树相同当且仅当它们的结构相同，并且每个节点的值也相同。 **解法思路** 可以通过递归或迭代的方式比较两棵树的每个节点： - 如果当前节点都为空，则相同。 - 如果一个为空而另一个非空，则不相同。 - 如果节点值不同，则不相同。 - 否则递归比较左右子树。 #### Java 解法示例（递归） ```java public boolean isSameTree(TreeNode p, TreeNode q) { if (p == null && q == null) return true; if (p == null || q == null) return false; return p.val == q.val && isSameTree(p.left, q.left) && isSameTree(p.right, q.right); } ``` #### Java 解法示例（迭代，使用队列） ```java public boolean isSameTree(TreeNode p, TreeNode q) { Queue<TreeNode> queue = new LinkedList<>(); queue.offer(p); queue.offer(q); while (!queue.isEmpty()) { TreeNode node1 = queue.poll(); TreeNode node2 = queue.poll(); if (node1 == null && node2 == null) continue; if (node1 == null || node2 == null || node1.val != node2.val) return false; queue.offer(node1.left); queue.offer(node2.left); queue.offer(node1.right); queue.offer(node2.right); } return true; } ``` **时间复杂度** - O(n)，其中 `n` 是树的节点数。 **空间复杂度** - 最坏情况下为 O(n)，取决于树的高度。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值