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

哈希表大多用来快速判断一个元素是否已经出现集合里，常常使用的三种数据结构为：

1，数组，常见使用在元素个数有限的情况下（26个字母）

2，set（集合），不需要映射时常常使用这个结构，例如不需要记录下标或只需要记录下标

3，map（映射），和字典一样，常常用于记录需要一一对应的情况。

集合	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::set	红黑树	有序	否	否	O(log n)	O(log n)
std::multiset	红黑树	有序	是	否	O(logn)	O(logn)
std::unordered_set	哈希表	无序	否	否	O(1)	O(1)

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::map	红黑树	key有序	key不可重复	key不可修改	O(logn)	O(logn)
std::multimap	红黑树	key有序	key可重复	key不可修改	O(log n)	O(log n)
std::unordered_map	哈希表	key无序	key不可重复	key不可修改	O(1)	O(1)

以上是set和map的几种实现，还需要学习红黑树等。

要使用集合来解决哈希问题的时候，优先使用unordered_set（无序，不能重复），因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set（有序，不能重复），如果要求不仅有序还要有重复数据的话，那么就用multiset（有序，可以重复）。

242.有效的字母异位词

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

针对26个字母（有限），更好的方法使用int [26]

class Solution {
public:
// 更好的方法是用int[26] 来代替哈希表
    bool isAnagram(string s, string t) {
        unordered_map<char, int> mp;
        for(char ca : s){
            mp[ca]++;
        }
        for(char ca : t){
            if(!mp.count(ca)){
                return false;
            }else{
                mp[ca]--;
            }
            if(mp[ca] == 0){
                mp.erase(ca);
            }
        }
        if(!mp.empty()){
            return false;
        }
        return true;
    }
};

349. 两个数组的交集

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

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> set;
        vector<int> res;
        for(int num1 : nums1){
            if(!set.count(num1)){
                set.insert(num1);
            }
        } 
        for(int num2 : nums2){
            if(set.count(num2)){
                res.push_back(num2);
                set.erase(num2);
            }
        }
        return res;
    }
};

202. 快乐数，

202. 快乐数 - 力扣（LeetCode）

class Solution {
public:
// hash表的作用为判断循环条件
    bool isHappy(int n) {
        unordered_set<int> set;
        int new_num = n;
        while(!set.count(new_num) && new_num != 1){
            set.insert(new_num);
            int sum = 0, div = new_num;
            while(div > 0){
                int remainder = div % 10;
                div = div / 10;
                sum += remainder * remainder;
            }
            new_num = sum;
        }
        if(new_num != 1){
            return false;
        }
        return true;
    }
};

1. 两数之和

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

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