求职 力扣 刷题 day06----哈希表

13. 哈希表

13.1 242.有效的字母异位词

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

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

思路：

1. 使用数组作为哈希表存储数据

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        char_counts = [0] * 26
        for char in s:
            index = ord(char) - ord('a')
            char_counts[index] += 1
        for char in t:
            index = ord(char) - ord('a')
            char_counts[index] -= 1
        
        for cnt in char_counts:
            if cnt != 0:
                return False
        return True

13.2 349. 两个数组的交集

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

哈希表，两次遍历

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        set_1 = set()
        for num in nums1:
            if num not in set_1:
                set_1.add(num)
        res_set = set()

        for num in nums2:
            if num in set_1 and num not in res_set:
                res_set.add(num)
        
        return list(res_set)

13.3 202. 快乐数

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

「快乐数」 定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
• 如果这个过程 结果为 1，那么这个数就是快乐数。

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

思路：

使用哈希表储存之前遍历过的数字，如果已经遍历过，表示重复则为False

class Solution:
    def isHappy(self, n: int) -> bool:
        num_set = set()
        num_set.add(n)
        while n != 1:
            res = 0
            while n:
                cur = n % 10
                res += cur ** 2
                n = n // 10
            n = res
            if n not in num_set:
                num_set.add(n)
            else:
                return False
        return True

13.4 1. 两数之和

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

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

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

思路：

1. 排序得到升序索引（sorted加lambda函数）
2. left, right = 0, len(nums) - 1 双指针

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:

        nums_sort_index = sorted(range(len(nums)), key=lambda x:nums[x])

        left, right = 0, len(nums) - 1
        while left < right:
            left_index = nums_sort_index[left]
            right_index = nums_sort_index[right]
            if nums[left_index] + nums[right_index] > target:
                right -= 1
            elif nums[left_index] + nums[right_index] < target:
                left += 1
            else:
                return [left_index, right_index]
        return

方法二：使用字典（推荐）

        #使用字典
        res_dict = dict()
        for index, num in enumerate(nums):
            if target - num in res_dict:
                return [index, res_dict[target - num]]
            else:
                res_dict[num] = index
        return