day 5 | 哈希表

目录

​​​​​​​242.有效的字母异位词

题目描述：

题解一：用列表[0] * 26 静态存储

题解二：用字典collections.defaultdict(int) 动态存储

349 两个数组的交集

题目描述：

题解一：动态字典

题解二：简单粗暴

题解三：排序加双指针（来自leetcode官方）

202 快乐数

题目描述：

题解一：快慢指针

题解二：列表存储

1 两数之和

题目描述：

题解一：双指针(也就是暴力解法）

题解二：哈希表（字典存储每个数字对应下标）

15  三数之和（为零）

题目描述：

题解：排序加双指针

---

​​​​​​​242.有效的字母异位词

题目描述：

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

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

提示:

• 1 <= s.length, t.length <= 5 * 104
• s 和 t 仅包含小写字母

题解一：用列表[0] * 26 静态存储

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        s_cnt = [0] * 26
        c_cnt = [0] * 26
        for _, e in enumerate(t):
            c_cnt[ord(e) - ord('a')] += 1
        for _, a in enumerate(s):
            s_cnt[ord(a) - ord('a')] += 1
        return True if c_cnt == s_cnt else False

题解二：用字典collections.defaultdict(int) 动态存储

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        t_dict = collections.defaultdict(int)
        l = 0
        for i, e in enumerate(t):
            t_dict[e] += 1
            l += 1
        for j, a in enumerate(s):
            if t_dict[a] > 0:
                t_dict[a] -= 1
                l -= 1
            elif t_dict[a] == 0:
                return False
        return True if l == 0 else False
            

349 两个数组的交集

题目描述：

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

题解一：动态字典

时空效率低！

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        nums1_dict = collections.defaultdict(int)
        ans = []
        for i, e in enumerate(nums1):
            e = str(e)
            nums1_dict[e] += 1
        for _, a in enumerate(nums2):
            # a = str(a)
            if nums1_dict[str(a)] > 0:
                ans.append(a)
                nums1_dict[str(a)] = 0
        return ans

题解二：简单粗暴

时空效率差不多

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        res = []
        for i, e in enumerate(nums1):
            if e in nums2:
                res.append(e)
        return list(set(res))

题解三：排序加双指针（来自leetcode官方）

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        nums1.sort()
        nums2.sort()
        length1, length2 = len(nums1), len(nums2)
        intersection = list()
        index1 = index2 = 0
        while index1 < length1 and index2 < length2:
            num1 = nums1[index1]
            num2 = nums2[index2]
            if num1 == num2:
                # 保证加入元素的唯一性
                if not intersection or num1 != intersection[-1]:
                    intersection.append(num1)
                index1 += 1
                index2 += 1
            elif num1 < num2:
                index1 += 1
            else:
                index2 += 1
        return intersection

202 快乐数

题目描述：

编写一个算法来判断一个数 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:
        slow, fast = n, n
        #下面这个写法有问题，因为一开始输入的是slow == fast
        # while fast != slow:
        #     slow = self.square_sum(slow)
        #     fast = self.square_sum(fast)
        #     fast = self.square_sum(fast)
        while True:
            slow = self.square_sum(slow)
            fast = self.square_sum(self.square_sum(fast))
            if slow == fast:
                break
        return fast == 1

    def square_sum(self, num):
        sum = 0
        while num > 0:
            sum += (num % 10) ** 2
            num = num // 10
        return sum

题解二：列表存储

class Solution:
    def isHappy(self, n: int) -> bool:
        l = []
        while n not in l:
            # 顺序反了，注意细节！！！
            # n = self.square_sum(n)
            # l.append(n)
            l.append(n)
            n = self.square_sum(n)
            if n == 1:
                break
        return n == 1

    def square_sum(self, num):
        sum = 0
        while num > 0:
            sum += (num % 10) ** 2
            num = num // 10
        return sum

1 两数之和

题目描述：

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

题解一：双指针(也就是暴力解法）

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        l = len(nums)
        slow, fast = 0, 0
        while slow < l and fast < l:
            fast += 1
            if nums[slow] + nums[fast] == target:
                return [slow, fast]
            if fast == l-1:
                fast = slow + 1
                slow += 1
        

题解二：哈希表（字典存储每个数字对应下标）

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        pos_dict = {}
        for i, e in enumerate(nums):
            if target - e in pos_dict.keys():
                return [pos_dict[target - e], i]
            pos_dict[e] = i
        

15  三数之和（为零）

题目描述：

给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请

你返回所有和为 0 且不重复的三元组。

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

题解：排序加双指针

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        ans = []
        # nums = nums.sort()
        nums.sort()
        if not nums:
            return ans
        l = len(nums)
        # 不对，因为内部不一定会执行i++，死循环
        # i = 0
        # while i < l - 2:
        for i in range(l - 2):
            if i > 0 and nums[i] == nums[i - 1]:  # Skip duplicates
                continue
 
            left, right = i + 1, l - 1
            
            while left < right:
                total = nums[i] + nums[left] + nums[right]
                
                if total < 0:
                    left += 1
                elif total > 0:
                    right -= 1
                else:
                    ans.append([nums[i], nums[left], nums[right]])
                    #不对，若有好几个重复的呢？
                    # left = left + 2 if nums[left + 1] == nums[left] else left + 1
                    # right = right - 2 if nums[right - 1] == nums[right] else right - 1 
                    while left < right and nums[left] == nums[left + 1]:  # Skip duplicates
                        left += 1
                    while left < right and nums[right] == nums[right - 1]:  # Skip duplicates
                        right -= 1
                        
                    left += 1
                    right -= 1
        
        return ans