代码随想录算法训练营第五天 | 哈希表 | 242 有效的字母异位词 | 349 两个数组的交集 | 202 快乐数 | 1 两数之和

哈希表基础

哈希表基础-资料链接

1.1 作用

快速判断一个元素是否在集合中
直接把元素映射为数组的索引，这样查找起来就是 O(1) 的时间复杂度

1.2 哈希函数

如何映射=>哈希函数

1.3 哈希碰撞

将映射名字时，两个名字映射到了一个位置

1.3.1 解决方法

拉链法
线性探索法

1.3.1.1 拉链法

发生冲突的元素都被存储在链表中

1.3.1.2 线性探索法

例如冲突的位置，放了小李，那么就向下找一个空位放置小王的信息

当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法

242 有效的字母异位词

242 有效的字母异位词-资料链接

解题思路

这题的话就是想一下映射函数嘛，其实就直接当成数组去做，因为字母就是按照ascii码去放不同的位置比如d放什么位置就是d-a这样，注意一下py的ascii码用ord()即可

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

if __name__=="__main__":
    solu=Solution()
    s="abcdefg"
    print(solu.isAnagram(s,s))
    

349 两个数组的交集

349 两个数组的交集-资料链接

我是先直接将数组转为set去重【慢】，卡哥上面的方法会快亿点 ，然后初始化{}，作为存放数据的地方

class Solution(object):
    def intersection(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        set1=set(nums1)
        set2=set(nums2)
        arr= {}
        res=[]
        for i in set1:
            arr[i]=1
        for i in set2:
            if i in arr.keys():
                res.append(i)
        return res

if __name__=="__main__":
    a=[1,2,4,6,9,10,2,2,2]
    b=[1,1,1,1,1,16,6,6]
    solu=Solution()
    print(solu.intersection(a,b))

202 快乐数

202 快乐数-资料链接

注意这里会出现死循环，需要用set判断是否出现过

class Solution(object):
    def isHappy(self, n):
        """
        :type n: int
        :rtype: bool
        """
        def calu_happy(n):
            happy_sum=0
            while n>0:
                happy_sum+=(n%10)**2
                n=n//10
            return happy_sum
        sum_=n
        res = {}
        while sum_!=1:
            sum_=calu_happy(sum_)
            if sum_ in res.keys():
                return False
            res[sum_]=1

        return True


if __name__=="__main__":
    a=2
    solu=Solution()
    print(solu.isHappy(a))

1 两数之和

1 两数之和-资料链接

这题需要的是一个新的数据结构叫做map，为什么会想到用hash来做呢，因为要查找元素是否在集合中。这题呢就是将遍历过的元素存数哈希表，然后遍历下一个的时候找一下哈希表中是不是有需要的元素，又因为哈希表中需要存值和下标，所以用map实现

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        map={}
        res=[]
        for i,v in enumerate(nums):
            find=target-v
            if map.get(find)!=None:
                res.append(i)
                res.append(map[find])
                return res

            map[v]=i
        return res



if __name__=="__main__":
    a=[2,7,11,5]
    t=9
    solu=Solution()
    print(solu.twoSum(a,t))