代码随想录python笔记3 哈希表

m0_63843129

已于 2023-03-10 00:49:26 修改

阅读量200

点赞数

分类专栏：代码随想录刷题笔记文章标签： python 散列表 leetcode

于 2023-03-09 22:01:14 首次发布

本文链接：https://blog.csdn.net/m0_63843129/article/details/129432323

版权

代码随想录刷题笔记专栏收录该内容

9 篇文章 0 订阅

订阅专栏

哈希表

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

哈希碰撞解决

拉链法
线性探测法

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

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

242.有效的字母异位词

力扣题目链接(opens new window)

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

示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true

示例 2: 输入: s = “rat”, t = “car” 输出: false

说明: 你可以假设字符串只包含小写字母

使用defaultdict

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        from collections import defaultdict
        s_dict = defaultdict(int)
        t_dict = defaultdict(int)
        for i in s:
            s_dict[i] += 1
        for j in t:
            t_dict[j] += 1
        return s_dict == t_dict

使用数组

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        record = [0] * 26
        for i in range(len(s)):
            record[ord(s[i]) -ord('a')] += 1
        for j in range(len(t)):
            record[ord(t[j]) - ord('a')] -= 1
        for k in range(26):
            if record[k] != 0:
                return False
        return True

使用Count

class Solution(object):
    def isAnagram(self, s: str, t: str) -> bool:
        from collections import Counter
        a_count = Counter(s)
        b_count = Counter(t)
        return a_count == b_count

349. 两个数组的交集

力扣题目链接(opens new window)

题意：给定两个数组，编写一个函数来计算它们的交集。

说明： 输出结果中的每个元素一定是唯一的。我们可以不考虑输出结果的顺序

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

第202题. 快乐数

力扣题目链接(opens new window)

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

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

如果 n 是快乐数就返回 True ；不是，则返回 False 。

示例：

输入：19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

class Solution:
    def isHappy(self, n: int) -> bool:
        def happy(num):
            s = 0
            while num:
                s += (num % 10) ** 2
                num = num // 10
            return s
        sn = set()
        while n != 1 and n not in sn:
            sn.add(n)
            n = happy(n)
        return n == 1

1. 两数之和

力扣题目链接(opens new window)

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        dic = dict()
        for index, value in enumerate(nums):
            if target - value in dic:
                return [dic[target - value], index]
            dic[value] = index
        return []

第454题.四数相加II

力扣题目链接(opens new window)

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2^28 - 1 之间，最终结果不会超过 2^31 - 1 。

例如:

输入:

A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]

输出:

解释:

两个元组如下:

(0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
(1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

class Solution:
    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
        dic = dict()
        for n1 in nums1:
            for n2 in nums2:
                if n1 + n2 in dic:
                    dic[n1 + n2] += 1
                else:
                    dic[n1 + n2] = 1
        count = 0
        for n3 in nums3:
            for n4 in nums4:
                if 0 - n3 - n4 in dic:
                    count += dic[0 - n3 - n4]
        return count

383. 赎金信

力扣题目链接(opens new window)

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

注意：

你可以假设两个字符串均只含有小写字母。

canConstruct(“a”, “b”) -> false
canConstruct(“aa”, “ab”) -> false
canConstruct(“aa”, “aab”) -> true

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        import collections
        c1 = collections.Counter(ransomNote)
        c2 = collections.Counter(magazine)
        x = c1 - c2
        #x只保留值大于0的符号，当c1里面的符号个数小于c2时，不会被保留
        #所以x只保留下了，magazine不能表达的
        if(len(x)==0):return True
        else:return False

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        # default
        from collections import defaultdict
        dic = defaultdict(int)
        for i in magazine:
            dic[i] += 1 # key记录值，value记录次数
        for j in ransomNote:
            if dic.get(j) is None or dic.get(j) == 0: # 按索引查找字典值
                return False
            else:
                dic[j] -= 1
        return True

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        # 数组哈希
        record = [0] * 26
        for i in magazine:
            record[ord(i) - ord('a')] += 1
        for j in ransomNote:
            if record[ord(j) - ord('a')] == 0:
                return False
            else:
                record[ord(j) - ord('a')] -= 1
        return True

第15题. 三数之和

力扣题目链接(opens new window)

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意： 答案中不可以包含重复的三元组。

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        # 排序+双指针
        ans = []
        nums.sort()  # 先排序
        n = len(nums)
        for i in range(n):
            left, right = i + 1, n - 1 #  定义双指针
            if nums[i] > 0:
                return ans
            if i > 0 and nums[i] == nums[i - 1]: # 注意，不能是nums[i] == nums[i + 1]
                continue # 第一个元素去重
            while left < right:
                if nums[i] + nums[left] + nums[right] < 0:
                    left += 1 
                elif nums[i] + nums[left] + nums[right] > 0:
                    right -= 1
                else: # 找到目标值后去重(也可以边找边去重)
                    ans.append([nums[i],nums[left],nums[right]])
                    # 找到之后，更新指针找下一个值
                    left += 1
                    right -= 1
                    # 去除第二第三个重复值（注意排除left = right情况）
                    while left < right and nums[left] == nums[left - 1]:  left += 1  
                    # 去除第二第三个重复值（注意排除left = right情况）
                    while left < right and nums[right] == nums[right + 1]: right -= 1 
        return ans

第18题. 四数之和–

力扣题目链接(opens new window)

题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

注意：

答案中不可以包含重复的四元组。

示例：给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。满足要求的四元组集合为： [ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]3

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        # 排序+双指针
        ans = []
        nums.sort()  # 先排序
        n = len(nums)
        for i in range(n):
            left, right = i + 1, n - 1 #  定义双指针
            if nums[i] > 0:
                return ans
            if i > 0 and nums[i] == nums[i - 1]: # 注意，不能是nums[i] == nums[i + 1]
                continue # 第一个元素去重
            while left < right:
                if nums[i] + nums[left] + nums[right] < 0:
                    left += 1 
                elif nums[i] + nums[left] + nums[right] > 0:
                    right -= 1
                else: # 找到目标值后去重(也可以边找边去重)
                    ans.append([nums[i],nums[left],nums[right]])
                    # 找到之后，更新指针找下一个值
                    left += 1
                    right -= 1
                    while left < right and nums[left] == nums[left - 1]:  left += 1  # 去除第二第三个重复值（注意排除left = right情况）
                    while left < right and nums[right] == nums[right + 1]: right -= 1 # 去除第二第三个重复值（注意排除left = right情况）
                    
        return ans

        left += 1
                right -= 1
                while left < right and nums[left] == nums[left - 1]:  left += 1  # 去除第二第三个重复值（注意排除left = right情况）
                while left < right and nums[right] == nums[right + 1]: right -= 1 # 去除第二第三个重复值（注意排除left = right情况）
                
    return ans