哈希表||L242.有效的字母异位词、L349. 两个数组的交集、L202. 快乐数、L1. 两数之和

哈希表
具有关键词、和关键词所对应的值

主要有三种：数组、set、map

set包括unordered_set，也优先使用，因为其查询和增删效率是最优的 要求有序就用set，也就是关键词不重复，若有重复就用multimap

map就是value不能一样，但是其值可以一样

当需要我们进行判断，是否有一个值出现过，或者查找某个值的属性就可以使用哈希表
http://L242.有效的字母异位词https://leetcode.cn/problems/valid-anagram/

#include<iostream>
using namespace std;
#include<unordered_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;
    }
};

http://L349. 两个数组的交集https://leetcode.cn/problems/intersection-of-two-arrays/

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

http:// 202. 快乐数https://leetcode.cn/problems/happy-number/

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

http://1. 两数之和https://leetcode.cn/problems/two-sum/

本题可以 采用暴力解法，但是算法嘛，学习嘛，还是得用算法来解决

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