代码随想录算法训练营第六天｜leetcode242.有效的字母异位词、leetcode349.两个数组的交集、leetcode202.快乐数、leetcode1.两数之和

当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。但是哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。

• 当我们要使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset。
• 那么再来看一下map ，在map 是一个key value 的数据结构，map中，对key是有限制，对value没有限制的，因为key的存储方式使用红黑树实现的。

1.242. 有效的字母异位词 - 力扣（LeetCode）。。。数组作为哈希表解决哈希问题

思路：这道题很简单，比如eae,aee这两个词，eae把对应字母出现的次数存入数组中，然后把aee每个字母出现的次数减下去，最后查看26位的数组对应值是否为0.
字符串处理：只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了

    bool isAnagram(string s, string t)
    {
        int record[26] = {0}; // 26个字母的哈希表
        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;
    }

2.349. 两个数组的交集 - 力扣（LeetCode）。。。通过set作为哈希表解决哈希问题

思路：这道题首先把nums1的数以哈希表的形式存入nums_set当中，然后遍历nums2，判断nums2中的元素在nums1能否找见，如果可以找见，就把所对应的元素存入结果数组当中(unordered_set可以去重)。
比如nums1:[2,3,4,3,4,5]. nums2:[2,2,4,4,5.3] =>nums<set>:[2,3,4,5],而不是统计次数。

做这道题时候的盲点：STL不太熟悉

• set：用于存储唯一元素,按键升序排序（集合）
• multiset:允许存储多个相同元素，按键生序排序（集合）
• unordered_set:用于存储唯一元素，不保证顺序 （集合）

• 插入元素：
  • insert(value)：插入一个元素。如果元素已存在，则不插入。返回一个 pair<iterator, bool>，其中 bool 表示是否插入成功。
• 查找元素：
  • find(key)：查找指定键的第一个元素，如果找到则返回指向该元素的迭代器，否则返回 end()。
  • count(key)：返回指定键的元素数量。
• 删除元素：
  • erase(key)：删除所有指定键的元素。
  • erase(iterator)：删除迭代器指向的元素。
  • clear()：清空 multiset 中的所有元素。
• 容量操作：
  • size()：返回 multiset 中元素的数量。
  • empty()：检查 multiset 是否为空。

• map：用于存储键值对，按键升序排序
• multimap: 用于存储多个具有相同键的键值对，按键升序排序
• unordered_map:用于存储键值对，不保证顺序

在常用STL方法当中，除了插入元素之外，其余方法都与set相同，只有插入元素不同

• 插入元素：insert(pair<key_type, mapped_type>(key, value))：插入一个键值对。如果键已存在，则不插入。返回一个 pair<iterator, bool>，其中 bool 表示是否插入成功。

从二者应用场景不同来剖析：

• set：常用于需要存储唯一元素并进行去重、查找某个元素是否存在等场景，例如统计一组数据中不同元素的个数。
• map：适用于需要建立键和值之间映射关系的场景，例如字典查询、统计每个单词出现的次数等。

    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;//用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);
            }
        }
        return vector<int>(result_set.begin(),result_set.end());
    }

3.202. 快乐数 - 力扣（LeetCode）

思路1:双指针法

19->82->68->100->0
设置快慢指针，快指针每次比慢指针多走一步，如果快慢指针相等且fast!=1，这证明链表成环形了，也就说“这个元素出现过了”。反之成立

    bool isHappy(int n) {
        if(n == 1) return true;
        int slow = n, fast = n;
        while(fast!=1){
            slow = getSum(slow);
            fast = getSum(getSum(fast));
            if(fast == slow&&fast!=1)
                return false;
        }return true;
    }

思路2:哈希表方法
开篇就讲过：当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。
这与本题很切合呢。所以这道题目使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false， 否则一直找到sum为1为止。判断是否重复出现就可以用unordered_set。

    int getSum(int n){
        int sum = 0;
        while(n){
            sum += (n % 10)*(n % 10);
            n /= 10;
        }
        return sum;
    }
    bool isHappy(int n) {
        if(n==1)return true;
        unordered_set<int> res;
        while(1){
            int sum = getSum(n);
            if(sum==1)
                return true;
            if(res.find(sum)==res.end()){//如果find()返回res.end()说明没找到
                res.insert(sum);
                n = sum;//更新
            }
            else
            {
                return false;
            }
        }
    }

4.1. 两数之和 - 力扣（LeetCode）

思路1:纯暴力，没啥意思～。。。

vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> res(2,0);
        for(int i = 0;i<nums.size();i++){
            for(int j = i+1;j<nums.size();j++){
                if(nums[i]+nums[j]==target){
                    res[0] = i;
                    res[1] = j;
                    return res;
                }continue;
            }
        }
        return {};

思路2:

当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。本题呢，我们需要一个集合来存放我们遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，也就是 是否出现在这个集合。那么我们就应该想到使用哈希法了。本题，我们不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。

    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int ,int> map;
        for(int i = 0;i<nums.size();i++){
            auto iter = map.find(target-nums[i]);
            if(iter!=map.end()){//找到了就返回
                return {iter->second,i};//注意C++11之后这么写返回vector也合法
            }
            map.insert(pair<int,int>(nums[i],i));

        }return {};
    }