代码随想录算法训练营第五天（py）|哈希表| 242.有效的字母异位词、349. 两个数组的交集、202. 快乐数-CSDN博客

本文链接：https://blog.csdn.net/uncle_tou/article/details/138815794

哈希表理论基础

哈希表是根据关键码的值直接进行访问的数据结构。
包括数组、集合、映射。
在cpp中，集合包括：

集合	底层实现	是否有序	数值能否重复	数值能否更改
std::set	红黑树	有序	否	否
std::multiset	红黑树	有序	是	否
std::unordered_set	哈希表	无序	否	否

映射包括：

集合	底层实现	是否有序	数值能否重复	数值能否更改
std::map	红黑树	有序	否	否
std::multimap	红黑树	有序	是	否
std::unordered_map	哈希表	无序	否	否

当我们要使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset。

当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

242.有效的字母异位词（easy）

力扣链接
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

思路1 排序后对比

秒杀

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        if sorted(s)==sorted(t):
            return True
        return False

思路2 哈希表

由于只有小写字符，那么可以定义一个长度为26的数组，用来记录字符串中字符出现的次数。
将a映射为下标0，z映射为下标25.
首先对字符串s遍历，每遇到一个字符就在对应元素+1.
然后对字符串t遍历，每遇到一个字符就在对应元素-1
最后判断数组是否为0

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

ord()转asc码

349. 两个数组的交集（easy）

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

思路1 转换为集合并使用&操作符秒杀

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

思路2 使用数组构建哈希表

用set的时间复杂度太大了，用数组会快很多。方法跟上一题的一样。

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        cnt1 = [0]*1001
        cnt2 = [0]*1001
        res = []
        for i in range(len(nums1)):
            cnt1[nums1[i]]+=1
        for i in range(len(nums2)):
            cnt2[nums2[i]]+=1
        
        for i in range(1001):
            if cnt1[i]*cnt2[i]!=0:
                res.append(i)
        return res

第202题. 快乐数（easy）

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

思路1 暴力

设置一个死循环，循环中进行快乐数计算，满足了则返回1，如果循环次数到达一定大则返回0

class Solution:
    def isHappy(self, n: int) -> bool:
        cnt = 0
        while True:
            cnt += 1
            string = str(n)
            n = 0
            for i in string:
                n += int(i) * int(i)
            if n == 1:
                return True 
            if cnt == 1000:
                return False

思路2 判断sum是否重复出现

思路1的方法会空耗很多时间，只要判断sum是否出现过，即可判断是否进入了死循环

class Solution:
    def isHappy(self, n: int) -> bool:
        seen = set()
        
        while True:
            string = str(n)
            n = 0
            for i in string:
                n += int(i) * int(i)
            if n == 1:
                return True
            if n in seen:
                return False
            seen.add(n)

1. 两数之和（easy）

力扣链接
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。

思路

暴力法太简单了，不赘述。
本题，我们不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。
Python 则将 <key,value> 结构的容器设为字典 dict
enumerate() 接受一个可迭代对象作为输入，并返回一个枚举对象，
例如

for index, val in enumerate(nums):

返回的就是索引和值

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