代码随想录算法训练营第五天 | 哈希表242,349,202,1

理论：

• 数组array，集合set，字典map都是哈希表
• 用哈希表判断一个元素是否出现过

1，有效字母的异位词

• 题目链接：242. 有效的字母异位词 - 力扣（LeetCode）
• 难度：简单
• 解题思路：元素范围比较小的时候，可以选择数组作为哈希表
  • 定义一个长度为26的数组，元素均为0
  • 1，先遍历s中的字符，在每个有该字符的位置下标索引中的元素 +1
    • 每个字母的asc码 - “a”的asc码，相对位置进行存储索引，索引为0-25
  • 2，再遍历t中的字符作为下标，查询是否出现在s里面，若出现过，则在每个相等的字符下标的位置 元素-1
  • 判断每个索引存储的元素是否都为0，若是，则true
• 难点和易错点：

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        record = [0] * 26
        for i in s:
            #并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
            record[ord(i) - ord("a")] += 1
        for i in t:
            record[ord(i) - ord("a")] -= 1
        for i in range(26):
            if record[i] != 0:
                #record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return False
        return True

2，两个数组的交集

• 题目链接：349. 两个数组的交集 - 力扣（LeetCode）
• 难度：简单
• 解题思路：集合
• 难点和易错点：

 方法一：集合

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        # 使用哈希表存储一个数组中的所有元素
        table = {}
        for num in nums1:
            table[num] = table.get(num, 0) + 1
        
        # 使用集合存储结果
        res = set()
        for num in nums2:
            if num in table:
                res.add(num)
                del table[num]
        
        return list(res)

 方法二：数组

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        count1 = [0]*1001
        count2 = [0]*1001
        result = []
        for i in range(len(nums1)):
            count1[nums1[i]]+=1
        for j in range(len(nums2)):
            count2[nums2[j]]+=1
        for k in range(1001):
            if count1[k]*count2[k]>0:
                result.append(k)
        return result

3，快乐数

• 题目链接：202. 快乐数 - 力扣（LeetCode）
• 难度：简单
• 解题思路：
• 难点和易错点：

方法一：使用集合

class Solution:
    def isHappy(self, n: int) -> bool:        
        record = set()

        while True:
            n = self.get_sum(n)
            if n == 1:
                return True
            
            # 如果中间结果重复出现，说明陷入死循环了，该数不是快乐数
            if n in record:
                return False
            else:
                record.add(n)

    def get_sum(self,n: int) -> int: 
        new_num = 0
        while n:
            n, r = divmod(n, 10)
            new_num += r ** 2
        return new_num

方法二： 使用数组

class Solution:
   def isHappy(self, n: int) -> bool:
       record = []
       while n not in record:
           record.append(n)
           new_num = 0
           n_str = str(n)
           for i in n_str:
               new_num+=int(i)**2
           if new_num==1: return True
           else: n = new_num
       return False

方法三：快慢指针

class Solution:
   def isHappy(self, n: int) -> bool:        
       slow = n
       fast = n
       while self.get_sum(fast) != 1 and self.get_sum(self.get_sum(fast)):
           slow = self.get_sum(slow)
           fast = self.get_sum(self.get_sum(fast))
           if slow == fast:
               return False
       return True
   def get_sum(self,n: int) -> int: 
       new_num = 0
       while n:
           n, r = divmod(n, 10)
           new_num += r ** 2
       return new_num

4，两数之和

• 题目链接：1. 两数之和 - 力扣（LeetCode）
• 难度：简单
• 解题思路：
• 难点和易错点：

方法一：使用字典

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

        for index, value in enumerate(nums):  
            if target - value in records:   # 遍历当前元素，并在map中寻找是否有匹配的key
                return [records[target- value], index]
            records[value] = index    # 如果没找到匹配对，就把访问过的元素和下标加入到map中
        return []

方法二：暴力法

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(len(nums)):
            for j in range(i+1, len(nums)):
                if nums[i] + nums[j] == target:
                    return [i,j]