哈希表部分算法题（代码随想录）

哈希表

1.有效的字母异位词

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

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

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

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

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 i in range(len(t)):
        record[ord(t[i])-ord('a')] -= 1
    for i in range(26):
        if record[i] != 0:
            return False
    return True

2.两个数组的交集

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
    t = [False]*1001
    for i in nums1:
        t[i] = True
    r = []
    for i in set(nums2):
        if t[i] is True:
            r.append(i)
    return r

3.快乐数

def isHappy(self, n: int) -> bool:
    s = set()
    while n != 1:
        if n in s:
            return False
        s.add(n)
        sum = 0
        t = n
        while t != 0:
            add = t % 10
            sum += add ** 2
            t = t // 10
        n = sum
    return True

4.两数之和

def twoSum(self, nums: List[int], target: int) -> List[int]:
    dict = {}
    for index,ele in enumerate(nums):
        if target - ele in dict:
            return [index,dict[target-ele]]
        else:
            dict[ele] = index

5.四数相加 II(2)

map保存数组A和B的数之和的count

思想可以学学，有点组合的思想

def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:
    dict = {}
    for i in nums1:
        for j in nums2:
            if i+j not in dict:
                dict[i+j] = 1
            else:
                dict[i+j] += 1
    count = 0
    for i in nums3:
        for j in nums4:
            temp = 0 - i - j
            if temp in dict:
                count += dict[temp]
    return count

6.赎金信

def canConstruct(self, ransomNote: str, magazine: str) -> bool:
    dict = {}
    for s in magazine:
        if s not in dict:
            dict[s] = 1
        else:
            dict[s] += 1
    for s in ransomNote:
        if s not in dict or dict[s] == 0:
            return False
        else:
            dict[s] -= 1
    return True

7.三数之和(2)

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

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

for 循环遍历数组 用头尾双指针指向数组两个元素

难点：注意i,left,right的去重

感觉更属于数组章节的算法：双指针

def threeSum(self, nums: List[int]) -> List[List[int]]:
    r = []
    nums.sort()
    n = len(nums)
    for i in range(n):
        if nums[i] > 0:
            return r
        if i >= 1 and nums[i] == nums[i-1]:
            continue
        left = i + 1
        right = n - 1
        while left < right:
            temp = nums[i] + nums[left] + nums[right]
            if temp > 0 :
                right -= 1
            elif temp < 0:
                left += 1
            else:
                r.append([nums[i],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
                right -= 1
                left += 1
    return r

8.四数之和(2)

题意：给定一个包含 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] ]

核心思想和三数之和差不多，只不过要两轮for循环遍历，然后再指定首尾双指针

要注意边界条件

def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
    n = len(nums)
    if nums is None or n < 4:
        return []
    r = []
    nums.sort()
    for i in range(n - 3):
        if i >= 1 and nums[i] == nums[i - 1]:
            continue
        for j in range(i + 1,n - 2):
            if j > i + 1 and nums[j] == nums[j - 1]:
                continue
            left = j + 1
            right = n - 1
            while left < right:
                temp = nums[i] + nums[j] + nums[left] + nums[right]
                if temp > target:
                    right -= 1
                elif temp < target:
                    left += 1
                else:
                    r.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
    return r