哈希表（散列表）基础概念与经典题目（Leetcode题解-Python语言）之中——实际应用

cnhwl

已于 2022-04-25 16:19:49 修改

阅读量534

点赞数 2

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

于 2021-07-17 19:54:04 首次发布

本文链接：https://blog.csdn.net/cnhwl/article/details/118861036

版权

Python与Leetcode刷题专栏收录该内容

44 篇文章 5 订阅

订阅专栏

上一节介绍了哈希表的原理与设计方法，这一节则直接python中现有的哈希表类型：哈希集合 set（集合）和哈希映射 dict（字典）来解决实际应用（刷题）。

零、概念
在介绍实际应用之前，有一个概念我认为是应该了解的，那就是可哈希（hashable）。官方的术语介绍如下：

一个对象的哈希值如果在其生命周期内绝不改变，就被称为 可哈希 （它需要具有 __hash__() 方法），并可以同其他对象进行比较（它需要具有 __eq__() 方法）。可哈希对象必须具有相同的哈希值比较结果才会相同。

可哈希性使得对象能够作为字典键或集合成员使用，因为这些数据结构要在内部使用哈希值。

大多数 Python 中的不可变内置对象都是可哈希的；可变容器（例如列表或字典）都不可哈希；不可变容器（例如元组和 frozenset）仅当它们的元素均为可哈希时才是可哈希的。用户定义类的实例对象默认是可哈希的。它们在比较时一定不相同（除非是与自己比较），它们的哈希值的生成是基于它们的 id()。

我的理解就是：由于python实现的集合和字典是基于哈希表或哈希函数的，为了确保键的唯一性（键与哈希值一一对应），则规定集合成员和字典中的键必须是可哈希的，这意味着其值在其生命周期内不会改变，所以又叫做不可变的。这样， Python 就可以创建一个唯一的哈希值来识别它，字典可以使用它来跟踪唯一键和集合来跟踪唯一值。

不可变类型（immutable types）：int, float, decimal, complex, bool, string, tuple, range, frozenset, bytes

可变类型（mutable types）：list, dict, set, bytearray, user-defined classes

一、哈希集合的应用

集合是用来存储非重复值的数据结构，因此，很自然地想到用集合进行查重和去重。

217.存在重复元素

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        hashset = set()  # 初始化
        for i in nums:
            if i in hashset:  # 元素是否为集合的成员
                return True
            else:
                hashset.add(i)  # 元素添加到集合
        return False

136. 只出现一次的数字

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        ans = set()
        for num in nums:
            if num in ans:
                ans.remove(num)
            else:
                ans.add(num)
        return ans.pop()

虽然可以用集合解决，但是此题最优的做法是位运算，原理是相同的数做异或运算 ^ 会得到0，而一个数与0做异或会得到这个数本身。所以，数组里面所有相同的数异或会得到0，而那个只出现一次的数再与0做异或，直接得到结果本身，代码如下：

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        ans = nums[0]
        for i in range(1, len(nums)):
            ans = ans ^ nums[i]
        return ans

349. 两个数组的交集

用自带的set，显然 return list(set(nums1) & set(nums2)) 即可，如果是自己实现取交集的操作呢？

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        set1 = set(nums1)
        set2 = set(nums2)
        return self.set_intersection(set1, set2)
    
    def set_intersection(self, set1, set2) -> List[int]:
        if len(set1) > len(set2):  #  考虑较小的数组
            return self.set_intersection(set2, set1)
        return [x for x in set1 if x in set2]

小技巧，两个数组的交集一定是在较小的数组当中。

202. 快乐数

class Solution:
    def isHappy(self, n: int) -> bool:
        notHappy = set()
        while True:
            numbers = list(str(n))
            total = 0
            for number in numbers:
                total += int(number) ** 2
            if total == 1:
                return True
            elif total in notHappy:  # 陷入无限循环
                return False
            else:
                notHappy.add(total)
                n = total

不停重复这个过程，直到这个数等于1（是快乐数），或者这个数等于之前出现过的数（陷入无限循环）。

二、哈希映射的应用

哈希映射是用于存储 (key, value) 键值对的一种实现，这意味着，我们在需要存储比键 key 的信息更多的信息（值 value 的信息）时，需要用到哈希映射。python中的对应自带类型为字典 dict。

1. 两数之和

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        record = dict()
        for i, num in enumerate(nums):
            if target - num in record:
                return [record[target - num], i]
            else:
                record[num] = i

这里的字典，就不仅存放了 nums 中不同元素的索引（作为键 key），还存放了 target - num 的值（作为值 value），这样当有元素等于这个值时，说明它们之和为target，同时可以输出它们的对应索引（键 key）。

更多关于两数、三数、四数之和的题解，可以看我的这篇文章。

205. 同构字符串

class Solution:
    def isIsomorphic(self, s: str, t: str) -> bool:
        s_table = dict()
        t_table = dict()
        for i in range(len(s)):
            if (s[i] in s_table and s_table[s[i]] != t[i]) or (t[i] in t_table and t_table[t[i]] != s[i]):
                return False
            else: 
                if s[i] not in s_table:
                    s_table[s[i]] = t[i]  # s到t的关系
                if t[i] not in t_table:
                    t_table[t[i]] = s[i]  # t到s的关系
        return True

判断两个字符串是否同构，即存在某种对应关系，注意这个关系得是双向成立的，因为可能字符串1中 a -> b 一定成立，但是字符串2中 b -> a 不一定成立。

599. 两个列表的最小索引总和

class Solution:
    def findRestaurant(self, list1: List[str], list2: List[str]) -> List[str]:
        RestaurantTable = dict()
        ans = list()
        num = 2005  # 大于2000即可
        for i, restaurant1 in enumerate(list1):
            RestaurantTable[restaurant1] = i
        for j, restaurant2 in enumerate(list2):
            if restaurant2 in RestaurantTable and RestaurantTable[restaurant2] + j <= num:
                if RestaurantTable[restaurant2] + j < num:
                    ans.clear()
                    ans.append(restaurant2)
                    num = RestaurantTable[restaurant2] + j
                else:
                    ans.append(restaurant2)

        return ans

用字典记录一个数组中的餐厅和对应索引值，再遍历另一个数组，如果出现同一个餐厅并且索引之和小于等于当前的最小值 num，则更新 ans 和 num（小于）或者添加餐厅到 ans（等于）。

387. 字符串中的第一个唯一字符

class Solution:
    def firstUniqChar(self, s: str) -> int:
        Hashtable = dict()
        for i, char in enumerate(s):
            if char in Hashtable:
                Hashtable[char] = -1
            else:
                Hashtable[char] = i
        ans = len(s)
        for char in Hashtable:
            if Hashtable[char] != -1 and Hashtable[char] < ans:
                ans = Hashtable[char]
        return ans if ans != len(s) else -1

遍历字符串，新出现的字符记录其索引，后面如果重复出现该字符，则值变成 -1（无论多少次出现都是 -1）。然后从ans = len(s) 开始，找到具有最小索引值的字符，若不存在则返回 -1。

350. 两个数组的交集 II

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        if len(nums1) > len(nums2):
            return self.intersect(nums2, nums1)
            
        c = collections.Counter()
        for n in nums1:
            c[n] += 1     
        ans = list()
        for m in nums2:
            if m in c and c[m] > 0:
                ans.append(m)
                c[m] -= 1
        
        return ans

开头还是小技巧，交集一定在较小的数组中。然后这里用到的是计数器类型 collections.Counter()，它是一个 dict 的子类，用于计数可哈希对象。它的特点就是如果引用的键没有任何记录，就返回一个0，而不是报错 KeyError 。这里的计数器用于存放元素在数组 nums1 出现的次数，然后遍历数组 nums2，每次边添加结果边计数器减一。这样就能使得输出结果中每个元素出现的次数，与元素在两个数组中出现次数的最小值一致。

219. 存在重复元素 II

class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
        hashtable = dict()
        for i, num in enumerate(nums):
            if num in hashtable and abs(i - hashtable[num]) <= k:
                return True
            else:
                hashtable[num] = i
        return False

用字典记录元素和它的索引值，后面出现相同元素时判断是否符合条件，不符合条件就更新索引值（离下一个相同元素更近）。

220. 存在重复元素 III

class Solution:
    def containsNearbyAlmostDuplicate(self, nums: List[int], k: int, t: int) -> bool:
        table = dict()
        for i in range(len(nums)):
            bucket_num = nums[i] // (t + 1) # 取商数作为桶的编号，每个桶大小为 t + 1

            # 存在当前编号的桶，即桶里面已经有东西了，则它们的值一定相差不大于 t
            if bucket_num in table:
                return True
            table[bucket_num] = nums[i]
            # 存在上一个编号的桶，到里面看看是否符合条件
            if (bucket_num - 1) in table and abs(table[bucket_num - 1] - nums[i]) <= t:
                return True
            # 存在下一个编号的桶，到里面看看是否符合条件
            if (bucket_num + 1) in table and abs(table[bucket_num + 1] - nums[i]) <= t:
                return True
            # 当 i 大于等于 k 时，下次遍历（i + 1）就不能考虑 nums[i-k] 了
            if i >= k:
                table.pop(nums[i - k] // (t + 1))
        return False

这题的核心思想就是分桶（分组），将遍历得到的数按数值范围放入不同的桶中（注意是取商数分桶而不是取余数），每个桶的大小为 t + 1。这样当有两个数出现在同一个桶时，它们的差距一定是小于等于 t 的；同一个桶中只有一个的话，就到相邻的桶看看是否符合条件，不相邻的桶就不用考虑了（值的差距一定大于 t）；最后要把距离当前索引 k 的那个值对应的桶删掉（索引的差距大于 k）。

359. 日志速率限制器

class Logger:

    def __init__(self):
        """
        Initialize your data structure here.
        """
        self.hashtable = dict()


    def shouldPrintMessage(self, timestamp: int, message: str) -> bool:
        """
        Returns true if the message should be printed in the given timestamp, otherwise returns false.
        If this method returns false, the message will not be printed.
        The timestamp is in seconds granularity.
        """
        if message in self.hashtable:
            if timestamp >= self.hashtable[message]:
                self.hashtable[message] = timestamp + 10
                return True
            else:
                return False
        else:
            self.hashtable[message] = timestamp + 10
            return True

用字典记录信息和它下一次可以打印的时间，实际上只有打印过并且没到下一次时间的信息会返回False，其余都是更新时间并返回True。

cnhwl

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
哈希表（散列表）基础概念与经典题目（Leetcode题解-Python语言）之中——实际应用

上一节介绍了哈希表的原理与设计方法，这一节则直接python中现有的哈希表类型：哈希集合 set（集合）和哈希映射 dict（字典）来解决实际应用（刷题）。零、概念在介绍实际应用之前，有一个概念我认为是应该了解的，那就是可哈希（hashable）。官方的术语介绍如下：一个对象的哈希值如果在其生命周期内绝不改变，就被称为可哈希（它需要具有 __hash__() 方法），并可以同其他对象进行比较（它需要具有 __eq__() 方法）。可哈希对象必须具有相同的哈希值比较结果才会相同。可哈希性使得对象能
复制链接

扫一扫