代码随想录算法训练营第五天 | 哈希表理论基础； 242.有效的字母异位词； 349. 两个数组的交集； 202. 快乐数； 1. 两数之和

哈希表理论基础：

哈希表都是用来快速判断一个元素是否出现集合里。

不同元素同时映射到哈希表同一个索引下标的位置，产生哈希冲突；采用拉链法或者线性探测法进行解决；

std::unordered_set，std::unordered_map为无序，底层为哈希表实现，其余为有序，底层为红黑树实现；优先使用unordered，速度快，需要key有序时再用其他；

242. 有效的字母异位词

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

用数组做的，不知道为什么最后一个循环必须是不等于然后false，我等于然后true就不行；

349. 两个数组的交集

注意去重问题，用数组去重不太会；后来知道那个unordered_set可以去重，直接定义这个把相等的加进去就行；

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;
        for(int i =0;i<nums1.size();i++){
            for(int j =0;j<nums2.size();j++){
                if(nums1[i]==nums2[j]){
                    result_set.insert(nums1[i]);
                }
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

注意哈希表定义以及添加返回的写法；

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

!=是因为如果找到了就不会等于end，只有没找到相交的才会等于end；注意for循环，是从num2中一直取num，循环遍历 nums2 数组中的每个元素，将当前元素赋值给变量 num

202. 快乐数

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> 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. 两数之和

简单的暴力解法，注意j的取值范围；

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        //int a[2] = {0};
        for(int i = 0;i<nums.size();i++){
            for(int j = i+1;j<nums.size();j++){
                if(nums[i]+nums[j] == target){
                    return {i, j};
                }
            }
        }
        return {};    
    }
};

采用哈希法；

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++){
            auto ir = map.find(target-nums[i]);
            if(ir != map.end()){
                return {ir->second, i};
            }
            map.insert(pair<int, int>(nums[i], i));
        }
        return {};
    }
};

主要是想到要在一个集合中查找符合条件的元素，如果满足就退出，不满足就一直往里加；注意哈希常用操作的一些写法；