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

hash是一种映射方式。解决哈希表相关的问题，要考虑如何去选择合适的哈希结构。

常用的哈希结构有数组，set，map三种。c++的STL里内置了几种类型的set和map。

用哈希表解题的时候可以按照以下思路选用哈希结构。

数组：元素大小不是特别大或较为连续分布。

set：元素要求去重，元素分布不太具有连续性或元素数值很大。

map:去重，或需要存放两个内容，如元素本身与下标的映射关系。

一些关于这些容器的常用的内容：

参考至：C++：set、map的使用及其特性和区别_c++set和map的区别-CSDN博客

set

1. set:里面每个元素只存有一个key值,如果这个key值之前存在的话就不插入。

2. multiset：可以插入key相同的值。

3. unordered_set：set 容器会自行对存储的数据进行排序，而unordered_set不会。

以下是set的常用方法。

//创建
set<int> s;
//遍历
for (auto e : s)
{
	cout << e << " ";
}
//插入
s.insert(2);
//查找
s.find(2);
//查找值为key的元素，如果找到，则返回一个指向该元素的正向迭代器；如果没找到，则返回一个与end()方法相同的迭代器
//清空
s.clear();//清掉所有数据

map

map是一种key(键),value(值)的形式，用来保存键和值组成的集合，键必须是唯一的，但值可以不唯一。里面的元素可以根据键进行自动排序，由于map是key_value的形式，所以map里的所有元素都是pair类型。pair里面的first被称为key(键），second被称为value(值）。

以下是map的常用方法。

//创建
map<string, string> dict;
//插入
dict.insert(pair<string, string>("string", "字符串"));//模板类型pair：构造了一个匿名对象插入到map
dict.insert(make_pair("apple", "苹果"));//模板函数make_pair：
dict.insert({ "left", "左边" });
//遍历
for (const auto &e : dict)
{
	cout << e.first << ":" << e.second << endl;
}
//查找:如果没找到，则返回一个与end()方法相同的迭代器
dict.find(2);

242. 有效的字母异位词

242. 有效的字母异位词 - 力扣（LeetCode）

说到统计元素出现的次数，第一反应是想到可以用map实现。

不过因为这道题数据在26个小写字母范围内，所以考虑用数组进行一个hash映射来解决。

将小写字母减去’a’，那么这些字母的范围便在0-25之内。在遍历s的时候把元素映射后加1，遍历t的时候把元素映射后减一。最后遍历hash数组看看元素是否都为0，便知道s和 t是不是互为字母异位词。

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

349. 两个数组的交集

349. 两个数组的交集 - 力扣（LeetCode）

这道题在没改数据范围之前，数值很大的时候受限于数组下标范围有限，所以应当使用set。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        set <int> num(nums1.begin(),nums1.end());//把nums1的元素转化至set里进行去重
        set <int> res;
        for(int i=0;i<nums2.size();i++){
            if(num.find(nums2[i])!=num.end()) res.insert(nums2[i]);//存进set里去重
        }
        return vector<int>(res.begin(),res.end());
        //通过使用vector的构造函数，将res中的元素复制到新的vector，并返回这个新的vector。
    }
};

不过在添加了元素的值都<1000的这个条件后，使用数组也可以把这个题解决。

（在这样的情况下用数组性能会比用set好一些，因为set每进行一次insert操作就要进行一次哈希运算，同时开辟一个新内存空间，用数组的话可以直接使用下标进行哈希映射）

题目要求返回去重的数组，所以要在统计时要进行一个去重操作。

1. 初始化hash数组为0，遍历nums1数组，hash数组对应映射值为0时说明元素没有出现过，添加一个映射：hash[nums1[i]]++；
2. 经过第一步处理后，hash数组内的值要么为0要么为1，在遍历nums2数组时，遇到hash映射为1的元素，可以考虑把hash映射的值减去2，使其等于-1。之所以-2是为了使得在nums2遍历中如果再次遇到重复的元素，保证只做一次操作。如（1 2 2 2 3 时，只有第一次出现2时，hash映射值为1，才会满足判断条件）。这样经过处理的hash数组内，映射值为-1表示这个元素是两个数组的交集。
3. 把值等于-1的元素加入结果数组内返回。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        int hash[1005]={0};
        vector <int> res;
        for(int i=0;i<nums1.size();i++){
            if(hash[nums1[i]]==0) hash[nums1[i]]++;
        }
        for(int i=0;i<nums2.size();i++){
            if(hash[nums2[i]]==1) hash[nums2[i]]-=2;
        }
        for(int i=0;i<1005;i++){
            if(hash[i]==-1) res.push_back(i);
        }
        return res;
    }
};

202.快乐数

202. 快乐数 - 力扣（LeetCode）

这道题第一眼会觉得很像数学题，所以就拿了几个数字来试试规律。

如果n在数次循环里的各位平方和(记为sum)为1，则为快乐数，否则继续循环。

题目说到可能是 无限循环 但始终变不到 1，既然会出现无限循环，那么说明sum曾经出现过。所以很自然会想到使用哈希表。因为一般情况下哈希表都被用来判断一个元素是否出现在集合里。

考虑使用去重且便于查找元素的set来进行解题。

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

    bool isHappy(int n) {
        set<int> nums;
        int sum = add(n);
        nums.insert(sum);
        while (1) {
            sum = add(sum);
            if (sum == 1)
                return true;
            if (nums.find(sum) != nums.end())//加和在集合里出现过的，说明会出现无限循环
                return false;
            nums.insert(sum);
        }
    }
};

1.两数之和

其实第一次读题的时候想过用双指针的方法，但是思考了一下觉得思路不太合适。

题目说明了只会存在一个有效答案，说明数据是不会出现类似[2,2,2,2,5,5]，target=7这种情况的。

考虑一下在遍历元素的时候，需要去查找有没有合适的元素满足两数之和，如果是试图一次遍历就解决问题，那么需要把遍历过的元素用一个容器进行存放，等到下一次去查找某元素是否在容器里出现过，如果出现过就说明找到答案。

因为要同时存放元素及其下标，所以考虑使用map。

每次遍历计算出target与当前元素的差值x，查找x是否出现在map里。

如果没有合适的数，把当前正在遍历的元素和下标存放到map。

//x表示map内某元素，mp[x]则表示它的映射，也就是存放的下标。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        map <int,int> mp;
        vector <int> res;
        for(int i=0;i<nums.size();i++){
            int x=target-nums[i];
            if(mp.find(x)!=mp.end()){ 
                res.push_back(mp[x]);
                res.push_back(i);
                break;
            }
            mp[nums[i]]=i;
        }
        return res;
    }
};