算法 哈希表1 || 242.有效的字母异位词 349. 两个数组的交集 202 快乐数 1. 两数之和

核心：一般哈希表都是用来快速判断一个元素是否出现集合里

• 使用数组来做哈希的题目，是因为题目都限制了数值的大小。（242.有效的字母异位词）
• 当题目没有限制数值的大小，就无法使用数组来做哈希表了。（349. 两个数组的交集）
• 而且如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。
• 遇到哈希问题为什么不直接都用set，而要考虑数组：
  直接使用set 不仅占用空间比数组大，而且速度要比数组慢，set把数值映射到key上都要做hash计算的。在数据量大的情况，差距明显

242.有效的字母异位词

自己用数组制作一个hash表
创建一个大小为26的数组，对应26的字母。遍历s，将对应字母的位置++，遍历t将对应位置–，最后数组中有元素不为0，返回false，全为0 返回true。

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

349. 两个数组的交集

std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表， 使用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2){
        unordered_set<int> result_set;
        unordered_set<int> nums_set(nums1.begin(),nums1.end());
        for(int num : nums2){
            if(nums_set.find(num) != nums_set.end()){
                result_set.insert(num); 
                //防止nums2中有元素多次重合
            }
        }
        return vector<int>(result_set.begin(),result_set.end());
    }
};

202 快乐数

本题和上一题一样，用unordered_set就可以做到，不必使用unordered_map。使用map的想法是通过key对应的value计数来判断，但是这两题都只要看：数值是否出现，而不用得知出现几次，所以直接用set.find 是否等于 set.end()就可以实现。

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

1. 两数之和

本题，我们不仅要知道元素有没有遍历过，还有知道这个元素对应的下标**，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。**
思路：每出现一个元素，就去找map里面有没有配对元素，没有就把目前元素放入map。
本题中k是数值，v是该数值对应的下标。因为是两数之和，所以不必考虑数组中出现重复元素。并且题目中指明那个：只存在一个有效答案！例如{3，2，3，4} ，target = 7 这样的情况不会出现。例如{3，2，3，4} ，target = 6 的情况，在遍历到第二个3的时候会去找配对值3，能找到，直接返回即可，也不存在因为元素无法重复而找不到的情况。
关于题干中：一个元素只能使用一次。因为是先找配对值，再添加，所以保证了找到的配对值都是之前添加的数，而不会是当前值本身。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target){
        unordered_map<int, int> map;
        for(int i = 0; i<nums.size(); i++){
            auto it = map.find(target - nums[i]);
            if(it != map.end()){
                return vector<int>{i,it->second};
            }
            else{
                map.insert(pair<int, int>(nums[i], i));
            }
        }
        return {};
    }
};