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

● 哈希表理论基础

数组：哈希值很小，范围可控;

set：数组很大;

map:有key  有value

a b c .....z

0 1 2      25

242.有效的字母异位词

#伪代码
hash[26];
先统计第一个字符串里每个字符出现的频率 然后遍历第二个字符串里的字符，出现一次hash对应元素-1

int hash[26];
for(i=0;i<s.size;i++0){
  hash[s[i]-'a']++;
}
for(i=0;i<s.size;i++){
  hasha[s[i]-'a']--
}

for(i=0;i<26;i++){
  if(hash[i]!=0){
     return false
}
}
return true;

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
        for i in range(len(record)):
            if(record[i]!=0):
                return False
        return True

349. 两个数组的交集

#伪代码
哈希表应用场景：这个元素是否在集合中出现过
step1:num1进行处理转变成哈希表的形式来存放num1中的元素
step2:num2去遍历每一个元素查询这个哈希表中是否出现过
step3：如果出现过 则将该元素放到result中

#code 用set
#这个用unordered set
unordered_set result;
unordered_set num_set(nums1);
for(i=0;i<nums2.size;i++){
 if(num_set.find(nums2[i]!=num_set.end()))
    result.insert(nums2[i]);}
return vector(result);

#code 用数组
int hash[1005]={0}
for(i=0;i<nums1.size;i++){
  hash[nums[i]]=1;}
for(i=0;i<nums2.size;i++){
  if(hash[nums2[i]]==1):
     result.insert(nums2[i]);}
return vector(result);

     

解法1：
class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        #用set
        val_dict={}
        result=[]        
        for num in nums1:
            val_dict[num]=1
        for num in nums2:
            if num in val_dict.keys() and val_dict[num]==1:
                result.append(num)
                val_dict[num]=0
        return result

解法2：
class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        #用数组
        hash=[0]*1005
        result=[]
        for num in nums1:
            hash[num]=1
        for num in nums2:
            if hash[num]==1:
                result.append(num)
                hash[num]=0
        return result

202.快乐数

class Solution:
    def isHappy(self, n: int) -> bool:
        def calculate_happy(num):
            sum=0
            while(num>0):
                sum+=(num%10)**2
                num=num//10
            return sum
        record_dict={}
        while True:
            n=calculate_happy(n)
            if n==1:
                return True
            elif n in record_dict.keys():
                return False
            else:
                record_dict[n]=1

 1. 两数之和

#伪代码
    元素  下标  存放这两个元素
map key   value key对应元素 因为查找的是元素是否出现过
map用来存放遍历过的元素

unordered_map(int,int) map
for(i=0;i<nums.size;i++){
   s=target-nums[i];
   iter=map.find(s);
   if(iter!=map.end()){
     return {iter→value,i};
   }
   map.insert(nums[i],i)
}
return ()

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