0242-leetcode算法实现之有效字母异位词-valid-anagram-python&golang实现

# 242.有效字母异位词

• https://leetcode-cn.com/problems/valid-anagram

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

注意：若s 和 t中每个字符出现的次数都相同，则称s 和 t互为字母异位词。

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

示例 2:
输入: s = "rat", t = "car"
输出: false

链接：https://leetcode-cn.com/problems/valid-anagram

python

# 0242.有效字母异位词

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        """
        哈希表比较,实现简单，借助哈希表实现对字符的计数，时间O(n), 空间有限空间，哈希存储
        思路：
        - 如果字符串长度不等，直接False
        - 否则，初始化哈希表，s_d, t_d
        - 遍历s,t，每次遍历对应key的val++
        - 最后返回哈希表比较结果，如果字母异位，则True，反之False
        :param s:
        :param t:
        :return:
        """
        from collections import defaultdict
        if len(s) != len(t):
            return False
        s_d = defaultdict(int)
        t_d = defaultdict(int)
        for i in range(len(s)):
            s_d[s[i]] += 1
            t_d[t[i]] += 1
        return s_d == t_d

    def isAnagram1(self, s: str, t: str) -> bool:
        """
        借助数组哈希, 数组下标即为字符 ascii对应数字，元素值为出现次数，时间O(n)，空间借助有限空间-数组哈希
        思路：
        - 如果字符串长度不等，返回False
        - 否则，初始化长度26的数组，初始化值为0
        - 遍历字符串s，记录每个字符对应出现次数，出现则++
        - 遍历字符串t,对饮字符如果出现则--
        - 最后再遍历记录数组，只要元素不为0，一定不是异位词
        :param s:
        :param t:
        :return:
        """
        if len(s) != len(t):
            return False
        records = [0] * 26
        n = len(s)
        for i in range(n):
            records[ord(s[i]) - ord('a')] += 1
        for i in range(n):
            records[ord(t[i]) - ord('a')] -= 1
        for i in range(26):
            if records[i] != 0:
                return False
        return True
if __name__ == "__main__":
    s = "handle"
    t = ""
    t1 = "and"
    t2 = "andhle"

    test = Solution()
    res = test.isAnagram(s, t)
    print(res) # False
    res = test.isAnagram(s, t1)
    print(res) # False
    res = test.isAnagram(s, t2)
    print(res) # True

golang

// 数组哈希 时间优
func isAnagram1(s, t string) bool {
	if len(s) != len(t) {
		return false
	}
	var hash [26]int
	for i := range s {
		hash[s[i]-'a']++
		hash[t[i]-'a']--
	}
	for _, v := range hash {
		if v != 0 {
			return false
		}
	}
	return true
}

// 哈希表
func isAnagram(s string, t string) bool {
	if len(s) != len(t) {
		return false
	}

	exists := make(map[byte]int)

	for i := 0; i < len(s); i++ {
		if v, ok := exists[s[i]]; v > 0 && ok {
			exists[s[i]] = v + 1
		} else {
			exists[s[i]] = 1
		}
	}

	for i := 0; i < len(s); i++ {
		if v, ok := exists[t[i]]; v >= 1 && ok {
			exists[t[i]] = v - 1
		} else {
			return false
		}
	}
	return true
}