【LeetCode】49. 字母异位词分组

最新推荐文章于 2026-05-11 21:48:52 发布

原创最新推荐文章于 2026-05-11 21:48:52 发布 · 495 阅读

2 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#字符串 #map #哈希

Leetcode 专栏收录该内容

103 篇文章

订阅专栏

本文介绍了如何解决LeetCode上的49号问题——字母异位词分组。通过质因数、排序比较和ASCII合并三种方法进行解析，详细探讨了每种方法的时间和空间复杂度，并提供了相关的代码实现。文章还提到了解决方案可能面临的挑战，如质因数方法中的整数溢出问题，并给出了参考链接以供进一步学习。

一、题目

给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。

示例:

输入: ["eat", "tea", "tan", "ate", "nat", "bat"]
输出:
[
  ["ate","eat","tea"],
  ["nat","tan"],
  ["bat"]
]

说明：

所有输入均为小写字母。
不考虑答案输出的顺序。

二、解决

1、质因数

思路：
基本原理： 算术基本定理，又称为正整数唯一分解定理，大于1的自然数，要么本身是质数，要么可以写成2个以上质数的和。而这些质因子按大小排列后，写法只有一种。

过程： 将26个字母映射为质因数，按大小排序，每个字符串可以映射为质因数相乘得到唯一的整数，进而判断是不是同一字符串。

举个栗子：
质因数

问题： 相乘的结果可能超出int范围。

代码：

class Solution {

    public List<List<String>> groupAnagrams(String[] strs) {
        HashMap<Integer, List<String>> hash = new HashMap<>();
        //每个字母对应一个质数
        int[] prime = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103 };
        for (int i = 0; i < strs.length; i++) {
            int key = 1;
            //累乘得到 key
            for (int j = 0; j < strs[i].length(); j++) {
                key *= prime[strs[i].charAt(j) - 'a'];
            } 
            if (hash.containsKey(key)) {
                hash.get(key).add(strs[i]);
            } else {
                List<String> temp = new ArrayList<String>();
                temp.add(strs[i]);
                hash.put(key, temp);
            }

        }
        return new ArrayList<List<String>>(hash.values());
    }
}

时间复杂度： O( $n k$ )，k是字符串的最长长度。
空间复杂度： O( $n k$ )

2、排序比较

思路：

将字符串分解成字符数组，然后排序比较，判断是不是同一组合。

代码：

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        if (strs == null || strs.length == 0) return new ArrayList<>();
        Map<String, List<String>> map = new HashMap<>();
        for (String s : strs) {
            char[] ca = s.toCharArray();
            Arrays.sort(ca);
            // valueOf(ca)：字符数组ca合并成字符串keyStr。
            String keyStr = String.valueOf(ca);
            if (!map.containsKey(keyStr)) map.put(keyStr, new ArrayList<>());
            map.get(keyStr).add(s);
        }
        return new ArrayList<>(map.values());
    }
}

时间复杂度： O( $n k l o g k$ )
空间复杂度： O( $n k$ )

3、ASCII合并

思路：

该算法思想的本质是把字符串映射为一组ASCII值，再合并为字符串作为key放入Map中，遇到相同的key，就加入value【List<String>】中。
在这里插入图片描述

代码：

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        if (strs == null || strs.length == 0) return new ArrayList<>();
        Map<String, List<String>> map = new HashMap<>();
        for (String s : strs) {
            char[] ca = new char[26];
            for (char c : s.toCharArray()) ca[c - 'a']++;
            String keyStr = String.valueOf(ca);
            if (!map.containsKey(keyStr)) map.put(keyStr, new ArrayList<>());
            map.get(keyStr).add(s);
        }
        return new ArrayList<>(map.values());
    }
}