【字符串】力扣242：有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例：

输入: s = "anagram", t = "nagaram"
输出: true

进阶: 如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？

最笨的方法

终于做出来了一道简单题！没有考虑unicode字符存在的情况。将两个字符串分别存在两个哈希表里，比较两个哈希表是否相等。时间复杂度O(m+n)。

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        ht, hm = {}, {}
        for char in s:
            ht[char] = 1 if char not in ht else ht[char] += 1
        for char in t:
            hm[char] = 1 if char not in hm else hm[char] += 1
        //return ht == hm
        return True if ht == hm else return False

python大法好

直接用计数器判断两个是否一致

from collections import Counter

class Solution3:
    def isAnagram(self, s: str, t: str) -> bool:
        return Counter(s) == Counter(t)

正经方法1：排序

t 是 s 的异位词 等价于「两个字符串排序后相等」。因此我们可以对字符串 s 和 t 分别排序，看排序后的字符串是否相等即可判断。此外，如果 s 和 t 的长度不同，t 必然不是 s 的异位词。

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        '''
        先判断长度，可以减少一些算例的判断时间
        if len(s) != len(t):
            return False
        '''
        return sorted(s) == sorted(t)

时间复杂度：O(nlogn)，其中 n 为 s 的长度。排序的时间复杂度为 O(nlogn)，比较两个字符串是否相等时间复杂度为 O(n)，因此总体时间复杂度为 O(nlogn + n)=O(nlogn)。

空间复杂度：O(logn)。排序需要 O(logn) 的空间复杂度。注意，在某些语言（比如 Java、JavaScript）中字符串是不可变的，因此我们需要额外的 O(n) 的空间来拷贝字符串。但是我们忽略这一复杂度分析，因为：① 这依赖于语言的细节；② 这取决于函数的设计方式，例如，可以将函数参数类型更改为 char[]。

正经方法2：哈希表

t 是 s 的异位词 等价于「两个字符串中字符出现的种类和次数均相等」。

• 定义一个数组 hash 用来记录字符串 s 里字符出现的次数。
• 把字符映射到数组也就是哈希表的索引下表上，因为字符 a 到 z 的ASCII是26个连续的数值，所以字符 a 映射为下表 0，相应的字符 z 映射为下表 25。此题并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。
• 遍历字符串 s 时，只需将 s[i] - ‘a’ 所在的元素做 +1 操作即可，并不需要记住字符 a 的ASCII，只要求出一个相对数值就可以了。这样就将字符串s中字符出现的次数，统计出来了。
• 如何检查字符串t中是否出现了这些字符？同样，在遍历字符串 t 的时候，对 t 中出现的字符映射哈希表索引上的数值再做 -1 操作。
• 最后判断
  • hash 数组如果有的元素不为 0，说明字符串 s 和 t 一定是谁多了字符或者谁少了字符，return False
  • hash 数组所有元素都为 0，说明字符串 s 和 t 是字母异位词，return True

1. 正经哈希表

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        m = len(s)
        n = len(t)
        if m != n:
            return False
        hash = [0] * 26 # 初始化哈希函数f(key) = key - ‘a’。由于两个字符串均只包含小写字母，所以初始化26个数组元素
        # 对于字符串s，在对应位置加（比如出现 a，就在 a 的位置 +1）
        for i in range(m):
            hash[ord(s[i]) - ord('a')] += 1
        # 对于字符串 t，在对应位置减（比如出现 a，就在 a 的位置 -1）
        for i in range(n):
            hash[ord(t[i]) - ord('a')] -= 1
        # 遍历哈希表。如果值都为 0，则为字母异位词；如果存在任一不为 0 的哈希值，则不为字母异位词
        for i in range(26):
            if hash[i] != 0:
                return False
        return True

时间复杂度：O(n)，其中 n 为 s 的长度。

空间复杂度：O(S)，其中 S 为字符集大小，此处 S=26。

2. 不新建数组作为哈希表，利用python的defaultdict

from collections import defaultdict
class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        s_dict = defaultdict(int)
        t_dict = defaultdict(int)
        for x in s:
            s_dict[x] += 1
        for x in t:
            t_dict[x] += 1
        return s_dict == t_dict

作者：carlsun-2
链接：https://leetcode.cn/problems/valid-anagram/solution/dai-ma-sui-xiang-lu-dai-ni-gao-ding-ha-x-hhwm/

标签：字符,return,str,异位,复杂度,力扣,哈希,242,字符串
来源： https://www.cnblogs.com/Jojo-L/p/16424661.html