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

哈希表理论基础 

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

文章讲解：代码随想录

242.有效的字母异位词 

题目链接：Valid Anagram - LeetCode

题目链接/文章讲解/视频讲解： 代码随想录

解题思路：

创建两个hash table记录两个string的字母个数

return 她们是否相等

class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        hash_s={}
        hash_t={}
        for letter in s:
            if letter in hash_s:
                hash_s[letter]+=1
            else:
                hash_s[letter] = 1
        for letter in t:
            if letter in hash_t:
                hash_t[letter]+=1
            else:
                hash_t[letter] = 1
        return hash_s==hash_t  
        

- 时间复杂度 O(n)

- 空间复杂度 O(1) 因为字母只有26个

349. 两个数组的交集 

题目链接：LeetCode - The World's Leading Online Programming Learning Platform

题目链接/文章讲解/视频讲解：代码随想录

解题思路：

创建第一个nums的hash表

如果第二个nums的数字存在在第一个hash_table就return 同时注意不要重复

class Solution(object):
    def intersection(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        #set up hashtable
        hash_1={}
        result=[]
        #count number for hash_1
        for i in nums1:
            if i not in hash_1:
                hash_1[i]=1
        #select
        for i in nums2:
            if i in hash_1 and (i not in result):
                    result.append(i)
        return result

- 时间复杂度 O(m+n)

- 空间复杂度 O(n) 

202. 快乐数 

题目链接：LeetCode - The World's Leading Online Programming Learning Platform

题目链接/文章讲解：代码随想录

解题思路：

先定义一个总个位数平方加到第一位平方的和的方程

设置循环 先计算平方和 如果这个数字=1 return true 如果在hashtable说明他开始出现循环 return false 否则的话记录进hashtable继续循环计算平方和。

class Solution(object):
    def isHappy(self, n):
        """
        :type n: int
        :rtype: bool
        """
        #define a function adding numbers sqaure
        def caculate_sum(nums):
            sum_=0
            while nums:
                sum_ += (nums%10)**2
                nums = nums//10
            return sum_
        hash_table={}
        while True:
            n=caculate_sum(n)
            if n == 1:
                return True
            elif n in hash_table:
                return False
            else:
                hash_table[n]=1

tip：可以使用unordered set

set.add(n)

class Solution(object):
    def isHappy(self, n):
        """
        :type n: int
        :rtype: bool
        """
        visited = set()
        cur = str(n)
        while cur not in visited:
            cur_sum = 0
            for i in cur:
                cur_sum += int(i)**2
            if cur_sum == 1:
                return True
            visited.add(cur)
            cur = str(cur_sum)
        return False

- 时间复杂度 O(logn)

- 空间复杂度 O(logn)

1. 两数之和 

题目链接/文章讲解/视频讲解：代码随想录

解题思路：

暴力 两个forloop

先设置hashtable 

遍历nums，如果target-当前数字的值在mapper里面，那么返回两者和， 否则就记录下当前数字。 若直到最后没有 返回false

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        mapper={}
        for i in range(len(nums)):
            if target-nums[i] in mapper:
                return mapper[target-nums[i]],i
            else:
                mapper[nums[i]]=i
        return False

- 时间复杂度 O(n)

- 空间复杂度 O(n)