代码随想录day6 哈希表 LeetCode 242.有效的字母异位词 349. 两个数组的交集 202. 快乐数 1. 两数之和

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

242.有效的字母异位词

 https://leetcode.cn/problems/valid-anagram/

由于哈希表只有26个元素，故采用数组做哈希表比较合适。

class Solution {
public:
    bool isAnagram(string s, string t) {
    int hash[26]={0};
    for(int i=0;i<s.size();i++){
        hash[s[i]-'a']++;
    }
    for(int i=0;i<t.size();i++){
        hash[t[i]-'a']--;
    }
    for(int i=0;i<26;i++){
        if(hash[i]!=0)return false;
    }
    return true;
    }
};

349. 两个数组的交集

https://leetcode.cn/problems/intersection-of-two-arrays/submissions/

第一种方法，用unordered_set做哈希表，效率较高，当用数组当哈希表下标数值大时需要选择这种方法

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> hash;
        unordered_set<int> result;
        hash.insert(nums1.begin(),nums1.end());
        for(int num:nums2){
            if(hash.find(num)!=hash.end())result.insert(num);
        }
        return vector<int>(result.begin(),result.end());

    }
};

第二种方法，这道题由于数值设计较小，也可用数组来做哈希表。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        int hash[1001]={0};//注意需要初始化,不初始化oj会随机取值
        unordered_set<int>result;
        for(int num1:nums1){
            hash[num1]=1;
        }
        for(int num2:nums2){
            if(hash[num2]==1)result.insert(num2);//这里还需要去重
        }
        return vector<int>(result.begin(),result.end());
    }
};

 202.快乐数

https://leetcode.cn/problems/happy-number/submissions/

这道题中如果不是快乐数就无限循环，说明肯定会出现原先出现的数，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。这道题数值也比较大，所以用了set做哈希表

class Solution {
public: 
    bool isHappy(int n) {
        unordered_set<int>hash;
        while(n!=1){
            hash.insert(n);
            int n1=0;
            while(n){
                int a=n%10;
                n1+=a*a;
                n/=10;
            }
            n=n1;
            if(hash.find(n)!=hash.end())return 0;
        }
        return 1;
    }
};

1. 两数之和  

https://leetcode.cn/problems/two-sum/submissions/

这道题可以用时间复杂度O(n^2)的暴力法，也可以用哈希法

利用map存储遍历过的元素，key为元素的值，value为下标，每次循环都调用一下map的查找。

class Solution {
public:
  vector<int> twoSum(vector<int>& nums, int target) {
      vector<int>result;
    int i=0;
    map<int,int>hash;
    for(int num:nums){
        if(hash.find(target-num)!=hash.end()){
           return{hash.find(target-num)->second,i};
        }
        hash.insert(make_pair(num,i++));
    }
    return {};
  }
};