代码随想录第五天|哈希表

242.有效的字母异位词

自写：分别为两个串创建两个map，然后判断两个map内的key和value是否相同即可。有点耗空间

class Solution {
public:
    bool isAnagram(string s, string t) {
        unordered_map<char,int> m1,m2;
        for(int i = 0; i < s.size(); i++){
            m1[s[i]]++;
        }
        for(int i = 0; i< t.size(); i++){
            m2[t[i]]++;
        }
        for(const auto& p:m1){
            if(m1[p.first] != m2[p.first]) return false;
        }
        for(const auto& p:m2){
            if(m1[p.first] != m2[p.first]) return false;
        }
        return true;
    }
};

创建一个数组当作map即可，然后让第一个串先用map记录，对应的字符数量+1，在遍历第二个串的时候再让对应的字符数量-1，如果最后的数组里每个字母对应的元素数不为0，则说明这两个串不是异位词。

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

349. 两个数组的交集

用数组模拟hash实现：

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

用set实现

class Solution {
public:
    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) {
            // 发现nums2的元素 在nums_set里又出现过
            if (nums_set.find(num) != nums_set.end()) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

202. 快乐数

用一个set保存曾经n改变过的数，如果一个数在set内重复出现，则代表该数的变换是一个循环，永远不会变成到1

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

1.两数之和

遍历数组，如果当前元素没有在map中出现过，那么就将key保存其值，value保存其下标。
之后再计算差值del = target - nums[i],判断该差值在map是否存在，如果存在则返回其下标和当前遍历元素的下标即可。

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