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

242. 有效的字母异位词

242. 有效的字母异位词

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

但是哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。

数组其实就是一个简单哈希表，数量比较少、的时候可以使用

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;
    }
};

int record[26]={0}  数组初始化

349. 两个数组的交集

349. 两个数组的交集

使用数组来做哈希的题目，是因为题目都限制了数值的大小。

如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。考虑使用set，而且还不要让数据重复，所以选择unordered_set。

直接使用set 不仅占用空间比数组大，而且速度要比数组慢，set把数值映射到key上都要做hash计算的。不要小瞧 这个耗时，在数据量大的情况，差距是很明显的。

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);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

用unordered_set去重

使用迭代器初始化 unordered_set<int> nums_set(nums1.begin(), nums1.end())；
使用迭代器初始化 vector<int>(result_set.begin(), result_set.end());
for (int num : nums2) 遍历 直接返回匿名对象

202. 快乐数

202. 快乐数

题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。

class Solution {
public:
    int getSum(int n) {
        int sum = 0;
        while (n) {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return sum;
    }

    bool isHappy(int n) {
        unordered_set<int> set;
        while (1) {
            int sum = getSum(n);
            if (sum == 1)
                return true;

            if (set.find(sum) != set.end())
                return false;
            else
                set.insert(sum);

            n = sum;
        }
    }
};

1. 两数之和

1. 两数之和

map是一种key value的存储结构，可以用key保存数值，用value再保存数值所在的下标

unordered_map

存储键值对 <key, value> 类型的元素，其中各个键值对键的值不允许重复，且该容器中存储的键值对是无序的

unordered_set

不再以键值对的形式存储数据，而是直接存储数据元素本身（当然也可以理解为，该容器存储的全部都是键 key 和值 value 相等的键值对，正因为它们相等，因此只存储 value 即可）。另外，该容器存储的元素不能重复，且容器内部存储的元素也是无序的。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map <int,int> map;
        for(int i = 0; i < nums.size(); i++) {
            // 遍历当前元素，并在map中寻找是否有匹配的key
            auto iter = map.find(target - nums[i]); 
            if(iter != map.end()) {
                return {iter->second, i};
            }
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int, int>(nums[i], i)); 
        }
        return {};
    }
};

auto iter = map.find(target - nums[i]); map.find(target - nums[i]) 返回的是一个迭代器，指向哈希表中查找到的元素（如果存在的话）。

std::unordered_map<int, int>::iterator iter = map.find(target - nums[i]);

map.insert() 的基本功能是在哈希表中插入一个键值对。如果键已经存在，则 insert 不会覆盖原有的值，而是保持哈希表不变，并返回一个 std::pair，表示插入操作的结果。

使用方括号 [] 直接给键赋值。如果键不存在，它会自动插入这个键并设置值。map[nums[i]] = i;
使用 emplace：map.emplace(nums[i], i);