代码随想录刷题记录（三）——哈希表

君子未期

于 2024-08-18 22:46:08 发布

阅读量924

点赞数 23

分类专栏： Python 刷题文章标签：数据结构哈希表 python leetcode

本文链接：https://blog.csdn.net/qq_43450589/article/details/141103599

版权

Python 同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

刷题

3 篇文章 0 订阅

订阅专栏

哈希表

1. 理论基础

哈希表概念：也称为散列表，是一种数据结构，它提供了快速的数据插入和查找功能。哈希表以 键值对（key-value pairs） 的方式存储数据。键是哈希表中用于唯一标识数据的元素。在很多情况下，键可以看作是数据的“名字”或“标签”。值是与键相关联的数据。在哈希表中，每个键都对应一个值，这个值可以是任何数据类型，比如数字、字符串、对象等。

在构造上，哈希表通过特定的哈希函数，将输入（键）转换为一个索引值（通常为整数），确定数据在表中的位置。键必须是唯一的，这意味着在同一个哈希表中，两个键值对不能有相同的键。值不是唯一的，不同的键可以对应相同的值，但每个键必须对应一个唯一的值。
不同键经过哈希函数计算得到相同的索引值，这成为“哈希冲突”，常用解决方法包括链地址法（Chaining）、开放地址法（Open Addressing）、双重哈希法（Double Hashing）
应用上，哈希表适用于快速判断一个元素是否出现在集合里。牺牲了空间换区时间，因为需要额外的数组，set或者map来存放数据，才能实现快速查找。

哈希碰撞解决方法一：拉链法
哈希碰撞解决方法二：线性探测法
常见的哈希结构：数组、集合、映射

2. 相关题目

有效的字母异位词

题目描述： 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
思路： 题目限制了数值的大小，采用数组来构造一个哈希表。用一个数组来判断字符串s中字母出现的频次，然后再逆向统计字符串t中字母出现的频次，若最后得到0数组，则表明所有字母出现的频次相同。注意，两个字符串应该要是等长的。这种方法实际上就是哈希表的一个简单应用，其中数组充当哈希表，数组的索引是哈希值，而数组中的计数则表示特定键（在这个例子中是字母）出现的次数

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        if len(s) != len(t):
            return False
        
        record = [0]*26
        for i in s: # 字符串也可以这么表示
            record[ord(i)-ord('a')] += 1 # [ord(i)-ord('a')]对应的是字母i的相对ASCII值，将其作为字母i的索引
        
        for i in t:
            record[ord(i)-ord('a')] -= 1 

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

        return True

349. 两个数组的交集

**题目描述：**给定两个数组 nums1 和 nums2 ，返回它们的交集。输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序。
**思路：**题目中没有限制数值的大小，所以最好采用集合/字典而不是数组来构造哈希表，同时注意要求给出去重后的结果。在python中，内置函数set很容易给出去重后的结果。

方法一：集合法

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        set1 = set(nums1) # 将nums1转换为集合
        set2 = set(nums2) # 将nums2转换为集合

        # 使用&运算符求两个集合的交集
        intersection_set = set1 & set2

        # 将交集集合转换回列表并返回
        return list(intersection_set)

方法二：自构造集合与字典法

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        # 创建一个字典来存储数组中所有的元素，采用nums1中的元素作为键，每个键对应的值是该元素在nums1中出现的次数
        dict = {}
        for i in nums1:
            dict[i] = dict.get(i,0) + 1 # 使用table.get(num, 0)获取num在dict中的当前计数（如果num不在dict中，则默认为0），然后将计数加1
        
        res = set() # 用一个集合来存储结果，如果采用字典，后续不能直接用list(dict)转换为列表
        for i in nums2:
            if i in dict:
                res.add(i) # 如果nums2中的数字i同样出现在dict中，则将该数字加到集合res中，然后将该数字在dict中删除
                del dict[i]
        return list(res)

202题. 快乐数

题目描述： 编写一个算法来判断一个数 n 是不是快乐数。「快乐数」定义为：

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

思路： 可能存在无限循环的情况，即sum会重复出现，所以可以采用集合记录出现过的sum。如果这个数字变成1后，以后重复求和过程仍然会为1，不会再跳出来。说明出现1之前，sum集合里不会有1（除非这个数就为1）。

class Solution:
    def isHappy(self, n: int) -> bool:
        record = set()
        while n not in record:
            record.add(n)
            new_num = 0
            n_str = str(n) # 想要逐位相加，先转换为str，每位求和后再转换为int
            for i in n_str:
                new_num += int(i)**2
            if new_num == 1:
                return True
            else: # 要记得将new_num转换为n，便于循环进行下去
                n = new_num
        
        return False # 已经出现循环了，且不是1

1. 两数之和

题目描述： 给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
思路： 如果用暴力解法复杂度为O(n²)。可以尝试对数组中的一个数i，找到target-i，看是否存在于数组之中，而为了减小搜索的复杂度，采用哈希表来构造搜索表。由于输入的数组包含两个信息量，数组的位置（索引）以及对应的数组值），我们采用字典来存储数组中的信息。其中，将元素值作为键，其好处是，当我们需要查找是否存在某个特定值（例如 target - value）时，我们可以直接通过键来快速访问其索引，这利用了哈希表的快速查找特性。如果使用索引作为键，即 records[index] = value，那么字典的键将是元素的索引，值是元素本身。这样做使得想要查找某个数是否存在，需要遍历records字典来找到匹配的值，将失去使用字典作为哈希表的优势。
问题： 如果让数组值作为字典的键，如果数组中存在重复元素，键不就重复了？
解答： 在Python字典中，键必须是唯一的，如果尝试用一个已经存在的键来存储值，原来的值会被新的值覆盖。这意味着，如果数组中有重复元素，字典将只会保留最后出现的元素及其索引。但依照题意，这里不用考虑这种情况。
注意： 在哈希表中查找一个元素的平均时间复杂度是O(1)。

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

        for index, value in enumerate(nums):
            if (target-value) in record: # 某个键是否存在于record之中，而record的值是需要通过键查询的
                return [record[target-value],index]
            else:
                record[value] = index
        
        return None

454题.四数相加II

题目描述： 给你四个整数数组 nums1、nums2、nums3 和 nums4 ，数组长度都是 n ，请你计算有多少个元组 (i, j, k, l) 能满足：

0 <= i, j, k, l < n
nums1[i] + nums2[j] + nums3[k] + nums4[l] == 0

思路： 将四个数组两两分为两组，

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        hashmap = dict() # 创建一个字典，也可以直接 = {}
        for n1 in nums1:
            for n2 in  nums2:
                if n1 +n2 in hashmap:
                    hashmap[n1+n2] += 1 # 对字典键的索引采用方括号[]
                else:
                    hashmap[n1+n2] = 1
        
        # 如果 -(nums3+nums4) 存在于hashmap，则满足四数相加为0
        count = 0
        for n3 in nums3:
            for n4 in nums4:
                key = -n3-n4
                if key in hashmap:
                    count += hashmap[key] # 统计满足条件的元组，
        return count

383. 赎金信

题目描述： 给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。如果可以，返回 true ；否则返回 false 。magazine 中的每个字符只能在 ransomNote 中使用一次。
思路： 可以用暴力解法，双层遍历（先magazine再ransomnote），对于ransomnote中的第j个字符与magazine中第i个字符相等，则在ransomnote中删除该字符，最后判断ransomnote是否为空。或者采用哈希解法，题目中致设计小写字母，可以用数组构造哈希表，用空间换时间，创建字典dict统计magazine中每个字符出现的次数，再遍历ransomnote中字符，在dict中减去相应字符的数量，如果遍历完没有出现“ransomnote”中有新字符，或者dict中对应字符数量为<0，则返回true。
相关题目： 242.有效的字母异位词

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        # 创建一个字典来存储 magazine 中每个字符的计数
        magazine_count = {}

        # 遍历 magazine 字符串，统计每个字符出现的次数
        for c in magazine:
            if c in magazine_count:
                magazine_count[c] += 1
            else:
                magazine_count[c] = 1

        # 遍历 ransomNote 字符串
        for c in ransomNote:
            # 如果字符不在 magazine 的计数字典中，或者计数为0，返回 False
            if c not in magazine_count or magazine_count[c] == 0:
                return False
            # 否则，将该字符在 magazine 中的计数减1
            magazine_count[c] -= 1

        # 如果所有字符都找到了，返回 True
        return True

15题. 三数之和

题目描述： 给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。答案中不可以包含重复的三元组。
思路1：哈希表法 首先这和二数之和、四数之和比较，分析能否用哈希表解决？思路为用两层for循环确定（a+b）的所有取值，利用哈希表寻找 -(a+b) 是否存在于数组中，但这会引入题目所不允许的重复的三元组，需要去重。

思路2：双指针法 本题采用双指针法复杂度更低【为什么？】，先对数组进行排序 【排序是进行双指针法的基础】 。然后从索引0遍历数组中的元素，记为i，a=nums[i]，再创建一个左指针left=i+1，b=nums[left]，右指针right=len(nums)-1，c=nums[right]，然后根据nums[i] + nums[left] + nums[right] 与 0 的大小关系决定往哪移动。
去重：① 对元素a去重，判断是否 num[i] == num[i-1]。这里不选择判断是否 num[i]+1 == num[i]，是因为这样容易错过类似{-1,-1,2}的数组。②对b，c元素去重，在 a+b+c == 0 的情况下，分别判断b，c与相邻元素是否一致。

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        result = []
        nums.sort() # 数组先排序

        # 开始遍历
        for i in range(len(nums)):
            # 如果第一个元素已经>0，不需要进一步检查
            if nums[0]>0:
                return result
            # 第一个元素开始去重
            if i > 0 and nums[i] == nums[i-1]:
                continue

            left = i+1
            right = len(nums)-1

            while right > left:
                sum1 = nums[i] + nums[left] + nums[right]

                if sum1 < 0:
                    left += 1
                elif sum1 > 0:
                    right -= 1
                else:
                    result.append([nums[i],nums[left],nums[right]])

                    # 去重，在满足a+b+c==0的情况下对bc进行去重，才有意义
                    while right > left and nums[right] == nums[right - 1]:
                        right -= 1
                    while right > left and nums[left] == nums[left + 1]:
                        left += 1                       
                    
                # 做完一轮判断后，指针移动
                left += 1
                right -= 1
        return result

18题. 四数之和

题目描述： 给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按任意顺序返回答案。

思路： 与三数之和的思路很类似，在此基础上再套一层for循环。和前面的四数之和不一样，前面是四个独立的数组，但本题设计一个数组。

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        # 老规矩，数组先排序
        nums.sort()
        n = len(nums)
        result = []
        for i in range(n):
            # 特殊情况判断
            if nums[i] > target:
                break
            # 对第一个元素a去重
            if i > 0 and nums[i] == nums[i-1]: 
                continue
            for j in range(i+1,n):
                if nums[i]+nums[j] > target :
                    break
                if j > i+1 and nums[j] == nums[j-1]: # 对j去重
                    continue
                left, right = j+1, n-1
                while left < right:
                    s = nums[i] + nums[j] + nums[left] + nums[right]
                    if s == target:
                        result.append([nums[i],nums[j],nums[left],nums[right]])
                        while left < right and nums[left] == nums[left+1]:
                            left += 1
                        while left<right and nums[right] == nums[right-1]:
                            right -= 1
                        
                        left += 1
                        right -= 1
                    elif s < target:
                        left += 1
                    else:
                        right -= 1
        return result

君子未期

关注

23
点赞
踩
29

收藏

觉得还不错? 一键收藏
0
评论
代码随想录刷题记录（三）——哈希表

这种方法实际上就是哈希表的一个简单应用，其中数组充当哈希表，数组的索引是哈希值，而数组中的计数则表示特定键（在这个例子中是字母）出现的次数。然后从索引0遍历数组中的元素，记为i，a=nums[i]，再创建一个左指针left=i+1，b=nums[left]，右指针right=len(nums)-1，c=nums[right]，然后根据nums[i] + nums[left] + nums[right] 与 0 的大小关系决定往哪移动。和前面的四数之和不一样，前面是四个独立的数组，但本题设计一个数组。
复制链接

扫一扫

专栏目录