秋招算法备战第6天 | 哈希表理论基础、242.有效的字母异位词、349. 两个数组的交集、202. 快乐数、1. 两数之和-CSDN博客

本文链接：https://blog.csdn.net/weixin_40951932/article/details/131540102

哈希表理论基础

一般哈希表都是用来快速判断一个元素是否出现集合里。

当我们想使用哈希法来解决问题的时候，我们一般会选择如下三种数据结构：

数组
set （集合）
map(映射)

当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。

但是哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。

242. 有效的字母异位词 - 力扣（LeetCode）

直接调库AC

from collections import Counter

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

看了下参考代码，可以直接创建一个26长度的哈希数组，然后判断，代码如下

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        record = [0] * 26
        for i in s:
            #并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
            record[ord(i) - ord("a")] += 1
        for i in t:
            record[ord(i) - ord("a")] -= 1
        for i in range(26):
            if record[i] != 0:
                #record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return False
        return True

349. 两个数组的交集 - 力扣（LeetCode）

先通过set得到去重的数据，然后依次判断

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        nums1 = set(nums1)
        nums2 = set(nums2)

        result = []
        for char in nums1:
            if char in nums2:
                result.append(char)
        
        return result

参考代码有两种值得参考，一个是使用数据作为哈希表（长度为10001，能够包含最长的输入），另一个是得到set后直接通过&操作

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        count1 = [0]*1001
        count2 = [0]*1001
        result = []
        for i in range(len(nums1)):
            count1[nums1[i]]+=1
        for j in range(len(nums2)):
            count2[nums2[j]]+=1
        for k in range(1001):
            if count1[k]*count2[k]>0:
                result.append(k)
        return result

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        return list(set(nums1) & set(nums2))

202. 快乐数 - 力扣（LeetCode）

模拟快乐数的过程，一次AC

class Solution:
    def isHappy(self, n: int) -> bool:
        track = []
        str_n = str(n)

        while str_n not in track:
            new_n = 0
            for char in str_n:
                new_n += int(char)**2
            if new_n == 1:
                return True
            track.append(str_n)
            str_n = str(new_n)
        
        return False

1. 两数之和 - 力扣（Leetcode）

稍微看了下视频，了解了思路，然后就写了。读题过程中很多细节没注意到，调了一会bug。

from collections import Counter
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        nums_dict = {}
        for i, num in enumerate(nums):
            if num not in nums_dict:
                nums_dict[num] = []
            nums_dict[num].append(i)

        for num in nums_dict.keys():
            if target-num in nums_dict.keys():
                if target != 2*num:
                    return [nums_dict[num][0], nums_dict[target-num][0]]
                else:
                    if len(nums_dict[num]) > 1:
                        return [nums_dict[num][0], nums_dict[target-num][1]]

        return None

看了下参考代码，发现自己写复杂了，在创建哈希表的过程中就可以判断，不需要全部创建完再判断，这样还可以省去对两个相同数相加情况的处理、

# 使用字典
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        records = dict()

        for index, value in enumerate(nums):  
            if target - value in records:   # 遍历当前元素，并在map中寻找是否有匹配的key
                return [records[target- value], index]
            records[value] = index    # 遍历当前元素，并在map中寻找是否有匹配的key
        return []

# 使用集合
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        #创建一个集合来存储我们目前看到的数字
        seen = set()             
        for i, num in enumerate(nums):
            complement = target - num
            if complement in seen:
                return [nums.index(complement), i]
            seen.add(num)