【码道初阶-Hot100】 LeetCode 49. 字母异位词分组：从排序哈希到分组映射，彻底讲透为什么排序后可以作为同一组的标识

LeetCode 49. 字母异位词分组：从排序哈希到分组映射，彻底讲透为什么排序后可以作为同一组的标识

摘要

LeetCode 49. 字母异位词分组（Group Anagrams） 是哈希表题目中的经典代表。题目本身不算复杂，但它非常适合训练一种关键思维：

字母异位词分组是一道非常典型的"构造统一特征值 + 哈希分组"题目。真正的关键不在于直接比较字符串，而在于为所有异位词找到同一个 key。这篇文章就从这个核心出发，彻底讲清楚为什么排序后的字符串可以作为分组依据，以及如何优雅地用 HashMap 完成分组。
如何为"本质相同、形式不同"的字符串构造统一标识。

在这道题中，所谓"字母异位词"，本质上就是：

字符种类完全相同
每种字符出现次数也完全相同
只是排列顺序不同

因此，解决问题的关键不在于直接比较两个字符串是否为异位词，而在于：

如何把所有互为异位词的字符串映射到同一个 key 上。

这篇文章将围绕这个核心思想展开，系统讲清楚：

为什么排序后的字符串可以作为分组 key
为什么 HashMap<String, List<String>> 能自然完成分组
代码每一步在做什么
时间复杂度和空间复杂度如何分析
这道题还能怎样进一步优化

如果真正理解了这篇文章，那么这道题就不再只是"背模板"，而会变成一道非常标准的"构造特征值 + 哈希分组"问题。

[LeetCode 49. 字母异位词分组：从排序哈希到分组映射，彻底讲透为什么排序后可以作为同一组的标识](#LeetCode 49. 字母异位词分组：从排序哈希到分组映射，彻底讲透为什么排序后可以作为同一组的标识)
- 摘要
- 目录
- 一、题目描述
- 二、什么是字母异位词
- 三、这道题真正的难点是什么
- - [1. 如何给一组异位词构造统一标识](#1. 如何给一组异位词构造统一标识)
  - [2. 如何把所有字符串按这个统一标识分组](#2. 如何把所有字符串按这个统一标识分组)
- 四、核心思路：排序后的字符串就是它的"标准形态"
- [五、为什么"排序后作为 key"一定正确](#五、为什么“排序后作为 key”一定正确)
- - [1. 如果两个字符串是异位词，那么排序后一定相同](#1. 如果两个字符串是异位词，那么排序后一定相同)
  - [2. 如果两个字符串排序后相同，那么它们一定是异位词](#2. 如果两个字符串排序后相同，那么它们一定是异位词)
  - [3. 所以可以得到一个双向结论](#3. 所以可以得到一个双向结论)
- [六、哈希表分组：把相同 key 的字符串放进同一个桶里](#六、哈希表分组：把相同 key 的字符串放进同一个桶里)
- 七、代码逐行精注释版
- 八、对代码中的每一步做更细致的解释
- - [1. 定义哈希表](#1. 定义哈希表)
  - [2. 遍历每个字符串](#2. 遍历每个字符串)
  - [3. 把字符串转成字符数组](#3. 把字符串转成字符数组)
  - [4. 排序字符数组](#4. 排序字符数组)
  - [5. 生成 key](#5. 生成 key)
  - [6. 若 key 不存在，就先创建一个新分组](#6. 若 key 不存在，就先创建一个新分组)
  - [7. 把原字符串加入对应分组](#7. 把原字符串加入对应分组)
  - [8. 返回所有分组](#8. 返回所有分组)
- [九、为什么最终返回 `new ArrayList<>(map.values())`](#九、为什么最终返回 new ArrayList<>(map.values()))
- - [1. `map.values()` 返回的是什么](#1. map.values() 返回的是什么)
  - [2. 为什么再套一层 `new ArrayList<>(...)`](#2. 为什么再套一层 new ArrayList<>(...))
- 十、这段代码里一个可以顺手优化的小细节
- - [1. 避免使用原始类型](#1. 避免使用原始类型)
  - [2. 泛型更清晰](#2. 泛型更清晰)
- [十一、可以进一步简化成 `computeIfAbsent`](#十一、可以进一步简化成 computeIfAbsent)
- 十二、用示例完整走一遍流程
- - [1. 处理 `"eat"`](#1. 处理 "eat")
  - [2. 处理 `"tea"`](#2. 处理 "tea")
  - [3. 处理 `"tan"`](#3. 处理 "tan")
  - [4. 处理 `"ate"`](#4. 处理 "ate")
  - [5. 处理 `"nat"`](#5. 处理 "nat")
  - [6. 处理 `"bat"`](#6. 处理 "bat")
- 十三、复杂度分析
- - 时间复杂度
  - 空间复杂度
- 十四、为什么这道题本质上是"构造特征值"的问题
- - 第一步：为每个元素提取一个标准特征
  - 第二步：让特征相同的元素进入同一组
- 十五、面试高频追问总结
- - [1. 为什么排序后可以作为 key](#1. 为什么排序后可以作为 key)
  - [2. 为什么不能直接用原字符串做 key](#2. 为什么不能直接用原字符串做 key)
  - [3. 为什么存入 map 的是原字符串，而不是排序后的字符串](#3. 为什么存入 map 的是原字符串，而不是排序后的字符串)
  - [4. `HashMap` 为什么适合这道题](#4. HashMap 为什么适合这道题)
  - [5. 这道题还能优化吗](#5. 这道题还能优化吗)
- 十六、可选优化：用字符计数代替排序
- - [为什么这个 key 也可行](#为什么这个 key 也可行)
- 十七、推荐的面试写法
- 十八、整道题的学习路线总结
- - 第一步：理解什么是异位词
  - 第二步：找到统一特征值
  - 第三步：用哈希表按特征值分组
  - [第四步：返回所有 value](#第四步：返回所有 value)
- 十九、结语

一、题目描述

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

示例：

java 复制代码

输入：strs = ["eat","tea","tan","ate","nat","bat"]
输出：[["bat"],["nat","tan"],["ate","eat","tea"]]

其中：

"eat"、"tea"、"ate" 互为字母异位词
"tan"、"nat" 互为字母异位词
"bat" 单独一组

二、什么是字母异位词

所谓字母异位词，意思是：

两个字符串包含的字符完全一样，并且每种字符出现的次数也一样，只是字符顺序不同。

例如：

java 复制代码

"eat" 和 "tea"
"tan" 和 "nat"

它们的字符组成相同，所以属于同一组。

而：

java 复制代码

"bat" 和 "tab"

虽然顺序不同，但字符组成完全一样，因此也是异位词。

三、这道题真正的难点是什么

这道题的难点不是"判断两个字符串是不是异位词"，而是：

1. 如何给一组异位词构造统一标识

例如：

java 复制代码

"eat"
"tea"
"ate"

这三个字符串顺序不同，但本质相同。必须想办法让它们映射到同一个 key。

2. 如何把所有字符串按这个统一标识分组

一旦能把同类字符串映射到同一个 key，剩下的问题就变成：

把 key 相同的元素放到同一个列表中。

这正是 HashMap 最擅长做的事情。

四、核心思路：排序后的字符串就是它的"标准形态"

这是整道题最关键的观察。

对于任意一个字符串，例如：

java 复制代码

"eat"

把它转成字符数组并排序：

java 复制代码

['a', 'e', 't']

再转回字符串：

java 复制代码

"aet"

再看另一个字符串：

java 复制代码

"tea"

排序后同样也是：

java 复制代码

"aet"

再看：

java 复制代码

"ate"

排序后还是：

java 复制代码

"aet"

这说明：

所有互为字母异位词的字符串，排序后一定会得到同一个结果。

因此，排序后的字符串就可以作为这一组异位词的"统一标识"。

这个统一标识，通常就叫做 key。

五、为什么"排序后作为 key"一定正确

这个结论可以从两个方向来理解。

1. 如果两个字符串是异位词，那么排序后一定相同

因为它们：

字符种类相同
每种字符个数相同

排序之后，相同字符会按照同样顺序排列，所以结果必然一致。

例如：

java 复制代码

"abbc" -> "abbc"
"babc" -> "abbc"
"cbab" -> "abbc"

2. 如果两个字符串排序后相同，那么它们一定是异位词

因为排序后的结果相同，说明这两个字符串排序后字符序列完全一致。

既然排序后字符完全一样，就说明它们的字符组成完全一样，因此一定互为异位词。

3. 所以可以得到一个双向结论

两个字符串互为异位词
当且仅当

它们排序后的结果相同

这就说明，用排序后的字符串作为 key 是完全正确的。

六、哈希表分组：把相同 key 的字符串放进同一个桶里

一旦为每个字符串找到了统一 key，问题就非常自然了。

可以定义一个哈希表：

java 复制代码

Map<String, List<String>> map

其中：

key：排序后的字符串
value：所有具有相同 key 的原字符串列表

例如处理下面这些字符串：

java 复制代码

["eat","tea","tan","ate","nat","bat"]

会形成如下映射：

java 复制代码

"aet" -> ["eat", "tea", "ate"]
"ant" -> ["tan", "nat"]
"abt" -> ["bat"]

最后只需要返回：

java 复制代码

map.values()

即可。

七、代码逐行精注释版

下面先给出一版适合讲解和正式提交的实现，并添加详细注释。

java 复制代码

import java.util.*;

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        // key：排序后的字符串
        // value：所有具有相同 key 的原字符串
        Map<String, List<String>> map = new HashMap<>();

        // 遍历输入数组中的每个字符串
        for (String s : strs) {
            // 将字符串转为字符数组，便于排序
            char[] tmp = s.toCharArray();

            // 排序后，互为字母异位词的字符串会得到相同的字符序列
            Arrays.sort(tmp);

            // 将排序后的字符数组重新转回字符串，作为哈希表的 key
            String key = new String(tmp);

            // 如果该 key 还没有对应的分组，就先创建一个空列表
            if (!map.containsKey(key)) {
                map.put(key, new ArrayList<>());
            }

            // 把当前原字符串加入对应分组
            map.get(key).add(s);
        }

        // map.values() 得到所有分组结果，再转成 List<List<String>> 返回
        return new ArrayList<>(map.values());
    }
}

八、对代码中的每一步做更细致的解释

下面把代码拆开解释，彻底讲透每一步在做什么。

1. 定义哈希表

java 复制代码

Map<String, List<String>> map = new HashMap<>();

这行代码非常关键。

它表示：

每一个 key 对应一组异位词
value 是这一组里的所有原字符串

换句话说，这个哈希表本身就是"分组容器"。

2. 遍历每个字符串

java 复制代码

for (String s : strs)

依次处理数组中的每一个字符串。

整道题的核心就是：

对每个字符串提取特征值，并根据特征值归类。

3. 把字符串转成字符数组

java 复制代码

char[] tmp = s.toCharArray();

因为字符串本身不能直接排序，所以要先转换成字符数组。

例如：

java 复制代码

"tea" -> ['t', 'e', 'a']

4. 排序字符数组

java 复制代码

Arrays.sort(tmp);

排序之后：

java 复制代码

['t', 'e', 'a'] -> ['a', 'e', 't']

这样，原本顺序不同但字符组成相同的字符串，就会变成同样的排序结果。

5. 生成 key

java 复制代码

String key = new String(tmp);

排序后的字符数组最终要变成字符串，才能作为哈希表 key 使用。

例如：

java 复制代码

['a', 'e', 't'] -> "aet"

于是：

"eat" 的 key 是 "aet"
"tea" 的 key 是 "aet"
"ate" 的 key 是 "aet"

它们自然就会进入同一组。

6. 若 key 不存在，就先创建一个新分组

java 复制代码

if (!map.containsKey(key)) {
    map.put(key, new ArrayList<>());
}

这段逻辑的含义是：

如果当前 key 第一次出现
说明这是一个新的异位词类别
需要先给它准备一个空列表

7. 把原字符串加入对应分组

java 复制代码

map.get(key).add(s);

注意这里加进去的是原字符串 s，不是排序后的 key。

因为题目要求返回的是原字符串分组结果，而不是排序后的形式。

8. 返回所有分组

java 复制代码

return new ArrayList<>(map.values());

map.values() 会返回哈希表中所有的 value，也就是所有分组列表。

再把它转成 ArrayList，就得到了题目要求的：

java 复制代码

List<List<String>>

九、为什么最终返回 `new ArrayList<>(map.values())`

这个写法是很多人第一次看到时容易迷糊的地方。

1. `map.values()` 返回的是什么

它返回的是：

java 复制代码

Collection<List<String>>

也就是哈希表中所有 value 的集合。

这些 value 本身就是：

java 复制代码

List<String>

所以整体就是：

java 复制代码

Collection<List<String>>

2. 为什么再套一层 `new ArrayList<>(...)`

因为题目要求返回类型是：

java 复制代码

List<List<String>>

而不是 Collection<List<String>>。

所以需要把这个集合再包装成一个 ArrayList：

java 复制代码

new ArrayList<>(map.values())

这样返回类型就和题目要求完全一致了。

十、这段代码里一个可以顺手优化的小细节

原代码里这一句写的是：

java 复制代码

map.put(k,new ArrayList());

这个写法虽然能跑，但更推荐写成：

java 复制代码

map.put(key, new ArrayList<>());

原因有两个：

1. 避免使用原始类型

new ArrayList() 是 raw type，泛型信息丢失，不够规范。

2. 泛型更清晰

new ArrayList<>() 会自动推导出这是一个 List<String>，更符合现代 Java 写法习惯。

所以博客里更推荐使用规范版本。

十一、可以进一步简化成 `computeIfAbsent`

如果想把代码写得更紧凑，Java 8 之后还可以这样写：

java 复制代码

import java.util.*;

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<>();

        for (String s : strs) {
            char[] tmp = s.toCharArray();
            Arrays.sort(tmp);
            String key = new String(tmp);

            map.computeIfAbsent(key, k -> new ArrayList<>()).add(s);
        }

        return new ArrayList<>(map.values());
    }
}

这句：

java 复制代码

map.computeIfAbsent(key, k -> new ArrayList<>()).add(s);

等价于：

如果 key 不存在，先创建空列表
然后把当前字符串加入列表

不过从教学和面试解释角度来说，前面的 containsKey + put + get 版本更适合初学者理解。

十二、用示例完整走一遍流程

以示例：

java 复制代码

["eat","tea","tan","ate","nat","bat"]

为例。

1. 处理 `"eat"`

转字符数组：['e','a','t']
排序后：['a','e','t']
key："aet"

哈希表变成：

java 复制代码

"aet" -> ["eat"]

2. 处理 `"tea"`

转字符数组：['t','e','a']
排序后：['a','e','t']
key："aet"

哈希表变成：

java 复制代码

"aet" -> ["eat", "tea"]

3. 处理 `"tan"`

排序后 key："ant"

哈希表变成：

java 复制代码

"aet" -> ["eat", "tea"]
"ant" -> ["tan"]

4. 处理 `"ate"`

排序后 key："aet"

哈希表变成：

java 复制代码

"aet" -> ["eat", "tea", "ate"]
"ant" -> ["tan"]

5. 处理 `"nat"`

排序后 key："ant"

哈希表变成：

java 复制代码

"aet" -> ["eat", "tea", "ate"]
"ant" -> ["tan", "nat"]

6. 处理 `"bat"`

排序后 key："abt"

哈希表变成：

java 复制代码

"aet" -> ["eat", "tea", "ate"]
"ant" -> ["tan", "nat"]
"abt" -> ["bat"]

最后返回所有 value 即可。

十三、复杂度分析

设：

字符串个数为 n
每个字符串平均长度为 k

时间复杂度

对于每个字符串：

转字符数组：O(k)
排序：O(k log k)
转回字符串：O(k)
哈希表插入：平均 O(1)

所以单个字符串复杂度是：

java 复制代码

O(k log k)

总复杂度是：

java 复制代码

O(n * k log k)

空间复杂度

主要额外空间包括：

哈希表存储所有分组
每次排序时的字符数组
key 字符串

总体空间复杂度通常写为：

java 复制代码

O(n * k)

因为最终所有字符串都被存进了 map 的 value 中，key 也需要额外空间。

十四、为什么这道题本质上是"构造特征值"的问题

这道题特别值得总结的一点是：

它不是简单的分组题，而是一道典型的"先构造统一特征值，再利用哈希表分组"的题。

这类题的通用套路是：

第一步：为每个元素提取一个标准特征

这里的标准特征就是：

java 复制代码

排序后的字符串

第二步：让特征相同的元素进入同一组

这一步由哈希表完成。

因此，这道题的本质可以概括为：

用排序后的字符串做 canonical form（标准形态），再用哈希表按标准形态聚类。

十五、面试高频追问总结

1. 为什么排序后可以作为 key

因为互为异位词的字符串，字符种类和数量完全一样，排序后一定得到相同结果；反过来，排序后相同，也说明它们字符组成完全一致。

2. 为什么不能直接用原字符串做 key

因为：

java 复制代码

"eat"
"tea"
"ate"

原字符串本身不同，直接做 key 会落在三个不同桶里，无法分组。

3. 为什么存入 map 的是原字符串，而不是排序后的字符串

因为题目要求返回的是原始字符串分组结果，而排序后的字符串只是用于分类的辅助标识。

4. `HashMap` 为什么适合这道题

因为哈希表支持：

通过 key 快速定位对应分组
平均 O(1) 完成插入和查找

非常适合做"按某种特征分类"的问题。

5. 这道题还能优化吗

可以。

当前解法的瓶颈在于排序，复杂度是：

java 复制代码

O(k log k)

如果字符串只包含小写字母，还可以用 字符计数 作为 key，把复杂度降到：

java 复制代码

O(k)

例如统计 26 个字母出现次数，然后拼成一个唯一字符串作为 key。

这样总时间复杂度可以优化到：

java 复制代码

O(n * k)

不过从"思路清晰、代码简洁、容易讲解"的角度看，排序法是非常经典且实用的标准解。

十六、可选优化：用字符计数代替排序

如果题目保证只包含小写字母，可以进一步写成：

java 复制代码

import java.util.*;

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<>();

        for (String s : strs) {
            int[] count = new int[26];

            for (char c : s.toCharArray()) {
                count[c - 'a']++;
            }

            StringBuilder keyBuilder = new StringBuilder();
            for (int num : count) {
                keyBuilder.append('#').append(num);
            }

            String key = keyBuilder.toString();

            map.computeIfAbsent(key, k -> new ArrayList<>()).add(s);
        }

        return new ArrayList<>(map.values());
    }
}

为什么这个 key 也可行

因为字符计数数组完整描述了：

每个字母出现多少次

只要两个字符串的计数数组相同，它们就一定是异位词。

这是一种"频次特征值"写法。

十七、推荐的面试写法

如果是面试中手写或现场讲解，更推荐下面这一版，逻辑清晰，代码规范，便于口述：

java 复制代码

import java.util.*;

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<>();

        for (String s : strs) {
            char[] chars = s.toCharArray();
            Arrays.sort(chars);
            String key = new String(chars);

            if (!map.containsKey(key)) {
                map.put(key, new ArrayList<>());
            }

            map.get(key).add(s);
        }

        return new ArrayList<>(map.values());
    }
}

这一版的优点是：

没有炫技写法
逻辑拆分明确
适合讲思路
面试官也容易跟上节奏

十八、整道题的学习路线总结

真正掌握 LeetCode 49. 字母异位词分组，建议按这个顺序理解：

第一步：理解什么是异位词

本质是字符组成相同，只是顺序不同。

第二步：找到统一特征值

排序后的字符串可以作为异位词的标准形态。

第三步：用哈希表按特征值分组

key 相同，就加入同一个列表。

第四步：返回所有 value

哈希表中的所有 value，正好就是题目要求的所有分组。

十九、结语

LeetCode 49. 字母异位词分组 是一道非常经典的哈希表题。它真正训练的，不只是 HashMap 的使用，而是一种更重要的算法思维：

当一类对象"本质相同但表现形式不同"时，

先尝试为它们构造一个统一、稳定的特征值，

再基于这个特征值做分类、统计或聚合。

在这道题里：

原字符串只是表现形式
排序后的字符串才是标准形态
哈希表则负责把相同标准形态的字符串归到同一组

把这个思路学透之后，很多"分组、归类、统计频次"的字符串题都会轻松很多。

【码道初阶-Hot100】 LeetCode 49. 字母异位词分组：从排序哈希到分组映射，彻底讲透为什么排序后可以作为同一组的标识

LeetCode 49. 字母异位词分组：从排序哈希到分组映射，彻底讲透为什么排序后可以作为同一组的标识

摘要

目录

文章目录

一、题目描述

二、什么是字母异位词

三、这道题真正的难点是什么

1. 如何给一组异位词构造统一标识

2. 如何把所有字符串按这个统一标识分组

四、核心思路：排序后的字符串就是它的"标准形态"

五、为什么"排序后作为 key"一定正确

1. 如果两个字符串是异位词，那么排序后一定相同

2. 如果两个字符串排序后相同，那么它们一定是异位词

3. 所以可以得到一个双向结论

六、哈希表分组：把相同 key 的字符串放进同一个桶里

七、代码逐行精注释版

八、对代码中的每一步做更细致的解释

1. 定义哈希表

2. 遍历每个字符串

3. 把字符串转成字符数组

4. 排序字符数组

5. 生成 key

6. 若 key 不存在，就先创建一个新分组

7. 把原字符串加入对应分组

8. 返回所有分组

九、为什么最终返回 new ArrayList<>(map.values())

1. map.values() 返回的是什么

2. 为什么再套一层 new ArrayList<>(...)

十、这段代码里一个可以顺手优化的小细节

1. 避免使用原始类型

2. 泛型更清晰

十一、可以进一步简化成 computeIfAbsent

十二、用示例完整走一遍流程

1. 处理 "eat"

2. 处理 "tea"

3. 处理 "tan"

4. 处理 "ate"

5. 处理 "nat"

6. 处理 "bat"

十三、复杂度分析

时间复杂度

空间复杂度

十四、为什么这道题本质上是"构造特征值"的问题

第一步：为每个元素提取一个标准特征

第二步：让特征相同的元素进入同一组

十五、面试高频追问总结

1. 为什么排序后可以作为 key

2. 为什么不能直接用原字符串做 key

3. 为什么存入 map 的是原字符串，而不是排序后的字符串

4. HashMap 为什么适合这道题

5. 这道题还能优化吗

十六、可选优化：用字符计数代替排序

为什么这个 key 也可行

十七、推荐的面试写法

十八、整道题的学习路线总结

第一步：理解什么是异位词

第二步：找到统一特征值

第三步：用哈希表按特征值分组

第四步：返回所有 value

十九、结语

九、为什么最终返回 `new ArrayList<>(map.values())`

1. `map.values()` 返回的是什么

2. 为什么再套一层 `new ArrayList<>(...)`

十一、可以进一步简化成 `computeIfAbsent`

1. 处理 `"eat"`

2. 处理 `"tea"`

3. 处理 `"tan"`

4. 处理 `"ate"`

5. 处理 `"nat"`

6. 处理 `"bat"`

4. `HashMap` 为什么适合这道题