哈希表01 | 242.有效的字母异位词、349. 两个数组的交集、202. 快乐数、1. 两数之和、*560. 和为k的子数组

哈希表用于需要快速判断某个元素是否存在的场景

242.有效的字母异位词

题目链接/文章讲解/视频讲解： https://programmercarl.com/0242.%E6%9C%89%E6%95%88%E7%9A%84%E5%AD%97%E6%AF%8D%E5%BC%82%E4%BD%8D%E8%AF%8D.html

• 考点
  • 哈希表（数组）
• 我的思路
  • 分别用两个长度为26的数组遍历记录两个输入字符串中每个字母出现的次数，这里的26分别对应26个英文字母，也就是说，我的哈希函数是0对应a一直到25对应z
  • 判断两个数组是否相等，不相等则返回False，否则为True
• 视频讲解关键点总结
  • 未看视频
  • 文字版讲解的思路和我类似
• 我的思路的问题
  • 无
• 代码书写问题
  • 无
• 可执行代码

class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        list_s = [0] * 26
        list_t = [0] * 26
        for a in s:
            list_s[ord(a) - ord('a')] += 1
        for b in t:
            list_t[ord(b) - ord('a')] += 1
        if list_s == list_t:
            return True
        else:
            return False

349. 两个数组的交集

题目链接/文章讲解/视频讲解：https://programmercarl.com/0349.%E4%B8%A4%E4%B8%AA%E6%95%B0%E7%BB%84%E7%9A%84%E4%BA%A4%E9%9B%86.html

• 考点
  • 哈希表（数组/集合/字典）
• 我的思路
  • 由于限定了输入值的范围，因此可以直接用数组来写
  • 把输入值一一对应到数组的序列值上，因此创建两个1001维的数组用来记录两个输入列表出现过的值
  • 记录完成后，创建一个新列表，在判断两个列表中相同位置的值均不为0时，储存结果，最终返回
• 视频讲解关键点总结
  • 未看视频
  • 文字版提供了多种思路，其中一种和上述相同
  • 使用集合的话，只需要一行代码return list(set(nums1) & set(nums2))
• 我的思路的问题
  • 无
• 代码书写问题
  • 无
• 可执行代码

class Solution(object):
    def intersection(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        l1 = [0] * 1001
        l2 = [0] * 1001
        result = []
        for data in nums1:
            l1[data] += 1
        for data in nums2:
            l2[data] += 1
        for i in range(1001):
            if l1[i] != 0 and l2[i] != 0:
                result.append(i)
        return result

202.快乐数

题目链接/文章讲解：https://programmercarl.com/0202.%E5%BF%AB%E4%B9%90%E6%95%B0.html

• 考点
  • 哈希数据结构（数组/集合）
  • 非快乐数的无限循环含义
• 我的思路
  • 外层大循环，while true
    • 第一个小循环取出当前n的每个数位，储存到列表中
    • 第二个小循环从列表中取值进行求和
    • 接下来进行判断
      • 如果和为1，当前数为快乐数，返回true
      • 如果和在之前的大循环中出现过，说明接下来会开启无限循环，即当前数不是快乐数，因此返回false
      • 和在之前没出现过、也不为1，则储存当前的和，之后开启下一轮大循环
• 视频讲解关键点总结
  • 未看视频
  • 文字版的重点已经总结到上面的我的思路里了，因为之前我的思路对无限循环的理解不到位
• 我的思路的问题
  • 之前没有理解好无限循环的含义，以为无限循环的情况不需要进行额外处理
• 代码书写问题
  • 无
• 可执行代码

class Solution(object):
    def isHappy(self, n):
        """
        :type n: int
        :rtype: bool
        """
        n_ = [n]
        while True:
            l = []
            while n:
                l.append(n % 10)
                n /= 10
            for data in l:
                n += data ** 2
            if n == 1:
                return True
            elif n in n_:
                return False
            else:
                n_.append(n)

1. 两数之和

题目链接/文章讲解/视频讲解：https://programmercarl.com/0001.%E4%B8%A4%E6%95%B0%E4%B9%8B%E5%92%8C.html

• 考点
  • 哈希结构（字典）
  • 利用差值的思路降低时间复杂度
• 我的思路
  • 暴力遍历所有的和值，过程中如果有和target相等的情况出现则返回
• 视频讲解关键点总结
  • 首先，想要判断数组中是否有两个元素的和值和target相等，利用差值的思路避免嵌套循环，比如target-当前元素得到差值，如果之前遍历过的元素中有该差值，则返回，否则继续向下遍历
  • 由于这里需要查询之前遍历过的元素，并且需要返回其对应的索引，因此使用字典结构，因为其查询速度快、且key-value结构与题意相符
• 我的思路的问题
  • 没有想到利用差值降低时间复杂度
• 代码书写问题
  • 无
• 可执行代码

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        dic = {}
        for index, data in enumerate(nums):
            if target - data in dic:
                return [dic[target - data], index]
            dic[data] = index
        return []

*560. 和为k的子数组

• 题干
  
• 思路
  • 暴力解法：外层遍历子数组起点，内层遍历子数组终点，通过每轮把当前终点元素的值加到和值里来判断该和值和目标值的关系，整体时间复杂度O（n^2），无法通过力扣
  • 优化解法：由于时间复杂度就是在两层循环上，因此考虑能不能拿掉一层循环；常见的拿掉循环的方式有哈希表，因此考虑这个地方能不能用到哈希表；分析发现，这个地方能用到的哈希表只有遍历过程中所求的子数组的和值
    • 此时想到（只能靠灵光乍现），如果记录一个前缀和表（从数组开头到当前元素的和值称为前缀和)，可以通过操作前缀和表得到以当前元素结尾的各段子数组的和值
    • 进一步优化的话，我们可以边算前缀和，边统计。遍历过程中，我们统计历史中每一个前缀和出现的个数，然后计算到i位置（含i）的前缀和presum减去目标k在历史上出现过几次，假如出现过m次，代表第i位以前（不含i）有m个连续子数组的和为presum−k，这m个和为presum−k的连续子数组，每一个都可以和presum组合成为presum−(presum−k)=k（来自力扣题解https://leetcode.cn/problems/subarray-sum-equals-k/solutions/1447027/python3-by-wu-qiong-sheng-gao-de-qia-non-w6jw/?envType=study-plan-v2&envId=top-100-liked）
    • 图例
• 代码

class Solution:
    def subarraySum(self, nums: List[int], k: int) -> int:
        presum = {0: 1}
        summation = 0
        result = 0
        for i in range(len(nums)):
            summation += nums[i]
            if summation - k in presum:
                result += presum[summation - k]
            if summation in presum:
                presum[summation] += 1
            else:
                presum[summation] = 1
        return result