LeetCode 题目 49：字母异位词分组 5种算法实现与典型应用案例【python】

最新推荐文章于 2024-05-30 20:15:33 发布

数据分析螺丝钉

最新推荐文章于 2024-05-30 20:15:33 发布

阅读量592

点赞数 10

分类专栏： LeetCode解锁1000题: 打怪升级之旅文章标签：算法 leetcode python 数据结构职场和发展

本文链接：https://blog.csdn.net/CCIEHL/article/details/137998136

版权

LeetCode解锁1000题: 打怪升级之旅专栏收录该内容

152 篇文章 58 订阅

订阅专栏

作者介绍：10年大厂数据\经营分析经验，现任大厂数据部门负责人。
会一些的技术：数据分析、算法、SQL、大数据相关、python
欢迎加入社区：码上找工作
作者专栏每日更新：
LeetCode解锁1000题: 打怪升级之旅
 python数据分析可视化：企业实战案例
备注说明：方便大家阅读，统一使用python，带必要注释，公众号数据分析螺丝钉一起打怪升级

题目描述

首先，字母异位词是指由相同字母以不同顺序组成的单词或短语。例如，“ate”, “eat”, 和 “tea” 是互为字母异位词的单词，因为它们都包含相同的字母 ‘a’、‘e’ 和 ‘t’，只是字母的顺序不同。

你需要编写一个函数来：

输入：一个字符串数组 strs，其中包含一系列单词。
处理：将这些单词分组，使得每一组内的单词都互为字母异位词。
输出：分组后的单词列表，这是一个列表的列表，其中每个子列表包含一组互为字母异位词的单词。

输入格式

strs：一个字符串数组。

输出格式

返回一个列表，每个子列表包含所有的字母异位词。

示例

示例 1

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

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

解释:

单词 “eat”, “tea”, 和 “ate” 互为字母异位词，因此它们被分为一组。
单词 “tan” 和 “nat” 互为字母异位词，所以它们被分为另一组。
单词 “bat” 自身独立成组，因为没有其他单词与其构成字母异位词。

示例 2

输入: strs = [""]
输出: [[""]]

算法分析

方法一：排序数组分类

解题步骤

创建哈希表：使用字典来组织异位词，键是排序后的单词，值是原单词的列表。
遍历字符串数组：对每个字符串排序，将排序后的字符串作为键，原字符串加入对应的列表。
输出结果：将哈希表的所有值转为列表输出。

完整的规范代码

def groupAnagrams(strs):
    """
    使用哈希表根据排序后的字符串分类字母异位词
    :param strs: List[str], 输入的字符串数组
    :return: List[List[str]], 分组后的字母异位词列表
    """
    anagram_map = {}
    for s in strs:
        sorted_s = ''.join(sorted(s))
        if sorted_s not in anagram_map:
            anagram_map[sorted_s] = [s]
        else:
            anagram_map[sorted_s].append(s)
    return list(anagram_map.values())

# 示例调用
print(groupAnagrams(["eat", "tea", "tan", "ate", "nat", "bat"]))

算法分析

时间复杂度：(O(nk \log k))，其中 (n) 是字符串的数量，(k) 是字符串的最大长度。
空间复杂度：(O(nk))，用于存储哈希表。

方法二：计数作为键

解题步骤

使用计数数组：对每个字符串，使用长度为26的计数数组（针对26个英文字母）来统计每个字母的出现次数。
转换为元组作为键：将计数数组转换为元组，用作哈希表的键。
分类存储：根据计数元组将字符串归类到对应的列表。

完整的规范代码

def groupAnagrams(strs):
    """
    使用字符计数数组作为哈希表键来分类字母异位词
    :param strs: List[str], 输入的字符串数组
    :return: List[List[str]], 分组后的字母异位词列表
    """
    anagram_map = {}
    for s in strs:
        count = [0] * 26  # 对应26个英文字母
        for char in s:
            count[ord(char) - ord('a')] += 1
        count_tuple = tuple(count)
        if count_tuple not in anagram_map:
            anagram_map[count_tuple] = [s]
        else:
            anagram_map[count_tuple].append(s)
    return list(anagram_map.values())

# 示例调用
print(groupAnagrams(["eat", "tea", "tan", "ate", "nat", "bat"]))

算法分析

时间复杂度：(O(nk))，其中 (n) 是字符串数量，(k) 是字符串的最大长度。
空间复杂度：(O(nk))，用于存储哈希表。

方法三：质数乘积作为键

解题步骤

使用质数：将26个英文字母映射到26个质数上。
计算哈希值：每个字符串通过其字符对应的质数的乘积得到一个

哈希值。
3. 分类存储：根据哈希值将字符串归类到对应的列表。

完整的规范代码

def groupAnagrams(strs):
    """
    使用质数乘积作为哈希键来分类字母异位词
    :param strs: List[str], 输入的字符串数组
    :return: List[List[str]], 分组后的字母异位词列表
    """
    primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101]
    anagram_map = {}
    for s in strs:
        key = 1
        for char in s:
            key *= primes[ord(char) - ord('a')]
        if key not in anagram_map:
            anagram_map[key] = [s]
        else:
            anagram_map[key].append(s)
    return list(anagram_map.values())

# 示例调用
print(groupAnagrams(["eat", "tea", "tan", "ate", "nat", "bat"]))

算法分析

时间复杂度：(O(nk))，其中 (n) 是字符串的数量，(k) 是字符串的平均长度。
空间复杂度：(O(nk))，主要用于存储输出结果。

方法四：改进的计数法

解题步骤

优化计数表示：与方法二相同，但使用字符串表示计数数组，减少转换开销。
使用字符串键：直接将计数数组转换成字符串形式，作为哈希键使用。

完整的规范代码

def groupAnagrams(strs):
    """
    使用改进的计数法（字符串键）分类字母异位词
    :param strs: List[str], 输入的字符串数组
    :return: List[List[str]], 分组后的字母异位词列表
    """
    anagram_map = {}
    for s in strs:
        count = [0] * 26
        for char in s:
            count[ord(char) - ord('a')] += 1
        key = '#'.join(map(str, count))  # 将计数数组转换为字符串形式
        if key not in anagram_map:
            anagram_map[key] = [s]
        else:
            anagram_map[key].append(s)
    return list(anagram_map.values())

# 示例调用
print(groupAnagrams(["eat", "tea", "tan", "ate", "nat", "bat"]))

算法分析

时间复杂度：(O(nk))，其中 (n) 是字符串的数量，(k) 是字符串的平均长度。
空间复杂度：(O(nk))，用于存储哈希表。

方法五：排序后哈希

解题步骤

直接排序：每个字符串排序，排序后的字符串作为键。
哈希表存储：相同排序结果的字符串归为一组。

完整的规范代码

def groupAnagrams(strs):
    """
    使用字符串排序后作为哈希键来分类字母异位词
    :param strs: List[str], 输入的字符串数组
    :return: List[List[str]], 分组后的字母异位词列表
    """
    anagram_map = {}
    for s in strs:
        key = ''.join(sorted(s))
        if key not in anagram_map:
            anagram_map[key] = [s]
        else:
            anagram_map[key].append(s)
    return list(anagram_map.values())

# 示例调用
print(groupAnagrams(["eat", "tea", "tan", "ate", "nat", "bat"]))

算法分析

时间复杂度：(O(nk \log k))，其中 (n) 是字符串的数量，(k) 是字符串的最大长度。
空间复杂度：(O(nk)\

)，用于存储哈希表和结果列表。

不同算法的优劣势对比

特征	方法一：排序数组分类	方法二：计数作为键	方法三：质数乘积作为键	方法四：改进的计数法	方法五：排序后哈希
时间复杂度	(O(nk \log k))	(O(nk))	(O(nk))	(O(nk))	(O(nk \log k))
空间复杂度	(O(nk))	(O(nk))	(O(nk))	(O(nk))	(O(nk))
优势	- 实现简单 - 易于理解	- 更快的运行时间 - 无需排序	- 唯一性好，冲突概率低 - 空间效率高	- 计数转字符串快 - 空间效率更优	- 代码简洁 - 实现直观
劣势	- 排序开销大	- 计数数组转换开销	- 质数映射复杂度高	- 字符串操作开销	- 排序时间开销大
适用场景	- 简单场景 - 教学演示	- 性能要求较高场景	- 避免哈希冲突场景	- 大数据量优化	- 代码简洁优先场景

在选择合适的方法时，应考虑实际的需求和问题规模。例如，对于需要快速处理的应用场景，可以选择计数作为键的方法；而对于需要代码简洁且易于理解的场景，则可以考虑排序后哈希的方法。对于需要避免哈希表冲突的复杂应用，质数乘积作为键提供了一个有趣的解决方案。

典型应用

字母异位词分组的应用示例覆盖了多个领域，包括数据处理、安全领域、文本分析等。这些应用不仅展示了算法的实用性，而且提供了对其在现实世界中的实际应用的洞见。

应用示例一：搜索引擎优化

场景描述

在搜索引擎技术中，快速识别并聚类含有相同字母的关键词（异位词）可以显著提高搜索结果的相关性和质量。例如，用户搜索“listen”的结果应该能够包含与“silent”相关的内容，因为它们是字母异位词。

实现步骤

关键词预处理：对搜索引擎数据库中的所有关键词进行异位词分组处理，创建一个从排序关键词到原始关键词列表的映射。
查询优化：
- 当用户提交一个搜索查询时，对查询词进行排序。
- 查找排序后与之匹配的所有异位词组，将这些词包括在搜索结果中。

代码示例

def preprocess_keywords(keywords):
    anagram_map = {}
    for keyword in keywords:
        sorted_keyword = ''.join(sorted(keyword))
        if sorted_keyword not in anagram_map:
            anagram_map[sorted_keyword] = [keyword]
        else:
            anagram_map[sorted_keyword].append(keyword)
    return anagram_map

def search(query, anagram_map):
    sorted_query = ''.join(sorted(query))
    return anagram_map.get(sorted_query, [])

# 示例关键词库和搜索
keywords = ["listen", "silent", "enlist", "google", "gooegl"]
anagram_map = preprocess_keywords(keywords)
print(search("tinsel", anagram_map))  # 输出: ['listen', 'silent', 'enlist']

应用示例二：安全审计

场景描述

在安全审计中，确保没有敏感词被无意识地使用是非常重要的。通过将敏感词库扩展为包含所有可能的字母异位词，可以增强审计过程的全面性，例如防止某些敏感信息在加密通讯中被隐藏。

实现步骤

敏感词库扩展：将所有敏感词及其异位词形式都纳入审计字典。
通讯内容检查：审查通过的所有消息都要检查是否包含这些敏感词或其异位词。

代码示例

def expand_sensitive_words(words):
    expanded_dict = {}
    for word in words:
        permutations = groupAnagrams([word])
        for perm in permutations[0]:
            expanded_dict[perm] = True
    return expanded_dict

def audit_communication(message, sensitive_dict):
    words = message.split()
    for word in words:
        if ''.join(sorted(word)) in sensitive_dict:
            return False
    return True

# 审计示例
sensitive_words = ["example", "word"]
sensitive_dict = expand_sensitive_words(sensitive_words)
message = "This is a simple wodr and an eaxmple."
print(audit_communication(message, sensitive_dict))  # 输出: False

算法优势与挑战

这些应用示例突出显示了字母异位词分组算法的多功能性和实用性。利用这种算法可以在不同场景下提供精确、高效的解决方案。然而，这也带来了一些挑战，如处理大数据集时的性能优化，以及在多语言环境中的应用适配等。通过不断优化算法实现和扩展其应用范围，可以更好地满足现实世界复杂多变的需求。

数据分析螺丝钉

关注

10
点赞
踩
27

收藏

觉得还不错? 一键收藏
打赏
7
评论
LeetCode 题目 49：字母异位词分组 5种算法实现与典型应用案例【python】

本文介绍了五种解决方案，包括排序数组分类、计数作为键、质数乘积键、改进计数法和排序后哈希，详述实现步骤和算法分析，并比较了各方法的优劣势。
复制链接

扫一扫