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

Leetcode 242 有效的字母异位词

242. 有效的字母异位词

思想：哈希表记录每个字母对应的数量就可以了，遇到能用哈希法的时候先想想能不能用数组，因为数组占用空间最小，分别把两个数组的键值对（值，数量）存入哈希表，最后比较两个哈希表是否相同就可以了。

难点：了解哈希表的用法 知道什么时候用数组，set，map

class Solution {
public:
    bool isAnagram(string s, string t) {
        //哈希表记录每个字母对应的数量就可以了
        //遇到能用哈希法的时候先想想能不能用数组
        if(s.size()!=t.size()) return false;
        unordered_map<char, int> hash_map1;
        unordered_map<char, int> hash_map2;
        for (int i = 0; i < s.size(); ++i) {
            hash_map1[s[i]]++;
        }
        // 记录字符串 t 中每个字母的数量
        for (int i = 0; i < t.size(); ++i) {
            hash_map2[t[i]]++;
        }
        for(auto it=hash_map1.begin();it!=hash_map1.end();it++){
            if(it->second !=hash_map2[it->first]){
                return false;
            }
        }
        return true; 
    }
};

Leetcode 349 两个数组的交集

349. 两个数组的交集

思想：首先把第一个数组存入哈希表，记住如果有重复的元素就跳过。然后查找第二个容器中的元素在哈希表中是不是存在，存在则加入res，并删除哈希表中对应的键值对，不然相同的值可能会被添加多次。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        //把第一个存入哈希表
        unordered_set<int> hash;
        
        for(int i=0;i<nums1.size();i++)
        {
            if(hash.find(nums1[i])==hash.end())  hash.insert(nums1[i]); 
        }
        
        vector<int> res;
        
        for(int i=0;i<nums2.size();i++){
            if(hash.find(nums2[i])!=hash.end()){
                hash.erase(hash.find(nums2[i]));
                res.push_back(nums2[i]);
            }
        }
        //查找第二个容器中的元素在哈希表中是不是存在 存在则加入res
        return res;
        
    }
};

Leetcode 202 快乐数

202. 快乐数

这个题一开始没想出来...看了题解才想明白哪里用到了哈希表，在本题中哈希表主要用来判断一个值之后的分开平方和相加的形式有没有被存储在哈希表中。如果有的话就说明已经卡在循环里面了，此时不是快乐数，反之则可以跳出循环，是快乐数。

class Solution {
public:
    bool isHappy(int n) {
        unordered_map<int,int> hash;
        
        while(n!=1){
            if(hash.find(n)!=hash.end()) return false;
            hash[n]=getsqt(n);
            n=hash[n];
        }
        return true;
        //
    }
    int getsqt(int n){
        int sum =0;
        string num = to_string(n);       
        for(int i=0;i<num.size();i++){
            sum+=(num[i]-'0')*(num[i]-'0');
        }
        return sum;
    }
};

Leetcode 1 两数之和

1. 两数之和

思想：一直往后遍历，在遍历到一个数的时候，看target与他的差是否已经被存入哈希表，如果是的话，返回之前的那个键值对中的下标和此时这个元素的下标。不是的话，将该数以及对应的键值对存入哈希表，继续向后遍历。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        //map存储已经遍历过的元素
        unordered_map<int,int> hash;
        vector<int> res;
        for(int i =0;i<nums.size();i++){
            //每访问过一个元素就看和他配对的那个元素是否被访问过
            if(hash.find(target-nums[i])!=hash.end()){
                res.push_back(hash[target-nums[i]]);
                res.push_back(i);
                
            }
            else{
                hash[nums[i]]= i;
            }
        }
        return res;
    }
};

收获：基本了解了map，set，数组的使用场景。对什么时候应该使用哈希表有了大概的认知，在题目要求中出现类似寻找某一个值是否出现过的时候，就应该考虑是否使用哈希法了。做的磕磕绊绊的，两个题没想出来。