算法训练 | Day6 哈希表理论基础，242.有效的字母异位词，349. 两个数组的交集 ，202. 快乐数，1. 两数之和

哈希表理论基础

• 哈希表：基于键、值对存储的数据结构

• 哈希表解决的问题：查询一个元素是否出现过，或者一个元素是否在集合里

• 常见的三种哈希结构：

1. 数组

2. set（集合）

3. map（映射）

242. 有效的字母异位词

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

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

s 和 t仅包含小写字母

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

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

解题思路

• 由于仅包含小写字母，可以用数组记录字符中每个字母出现的次数

• 因为字符a到字符z的ASCⅡ值为26个连续的数值，所以把字符映射到数组（哈希表）的索引，索引对应字符出现的次数。字符a的索引为0，字符z的索引为25

def isAnagram(self, s: str, t: str) -> bool:
        record = [0] * 26

        for i in range(len(s)):
            record[ord(s[i])-ord('a')] += 1

        for i in range(len(t)):
            record[ord(t[i])-ord('a')] -= 1

        for i in range(26):
            if record[i] != 0:
                return False
                break

        return True

总结

• 因为都是小写字母，范围是26，哈希表选择数组。想到把字符映射到数组索引上

• ord函数是以单个字符作为参数，返回对应的 ASCll 数值或者 Unicode 值

349. 两个数组的交集

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

题目链接：https://leetcode.cn/problems/intersection-of-two-arrays

解题思路

• 题目中没有限制长度，不能使用数组；且如果哈希值比较少，特别分散、跨度非常大，使用数组会造成空间浪费。

• 输出结果中每个元素是唯一的，且不考虑顺序。所以把数字映射为字典的key，如果数字出现，则对应value为1

def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        valid_dict = {}
        ans = []
        for num in nums1:
            valid_dict[num] = 1

        for num in nums2:
            if num in valid_dict.keys() and valid_dict[num] == 1:
                ans.append(num)
                valid_dict[num] = 0
        
        return ans

总结

• 范围没有限制，所以哈希表不选择数组

• 把数字映射为字典的key，如果数字出现，则对应value为1；已经记录到输出的key（数字），对应的value要置为0，避免重复比较

202. 快乐数

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。

• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。

• 如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

题目链接：https://leetcode.cn/problems/happy-number

解题思路

• 当要快速判断一个元素是否出现集合里的时候，就要考虑哈希法，哈希表选择set

• 难点在要熟悉如果对取数值各个位上的单数操作

def isHappy(self, n: int) -> bool:
        def calculate_happy(num):
            sum_ = 0
            while num:
                sum_ += (num%10) ** 2
                num = num // 10
            return sum_

        record = set()

        while True:
            n = calculate_happy(n)
            if n == 1:
                return True

            if n in record:
                return False
            else:
                record.add(n)

总结

• 平方和sum会重复出现，也可能无限循环，要判断sum是否存在或出现，选择哈希法，哈希表为集合

1. 两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

题目链接：https://leetcode.cn/problems/two-sum

总结

• 暴力解法：两层for循环

• 哈希法：要判断是否存在，考虑使用哈希法。由于需要返回存在元素的索引，元素要对应索引，考虑使用key-value的数据结构（字典）

1-暴力法

def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(len(nums)):
            for j in range(i+1, len(nums)):
                if nums[i] + nums[j] == target:
                    return[i, j]

2-哈希法

def twoSum(self, nums: List[int], target: int) -> List[int]:
        records = dict()
        for idx, val in enumerate(nums):
            if target - val not in records:
                records[val] = idx
            else:
                return [records[target - val], idx]

总结

• 哈希法：遍历原数组的元素val时，查询target - val是否存在，存在则将数值作为key，索引作为value