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

题目链接：242. 有效的字母异位词

class Solution
{
public:
    bool isAnagram(string s, string t)
    {
        unordered_map<char,int> record;
        if(s.size()!=t.size()) return false;
        for(int i=0;i<s.size();i++){
            record[s[i]]++;
        }
        for(int i=0;i<t.size();i++){
            record[t[i]]--;
            if(record[t[i]]<0) return false;
            //只有在s出现过的元素，在map里的value才会大于1，在这里被减1后的值才能大于0
        }
        return true;
    }
};

我的解题思路就是判断每一个字母的出现的次数，储存在哈希表里进行操作。时间复杂度o(n)，空间复杂度o(n)

这里有另一个思路，来自代码随想录的题解：

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = {0};
        for (int i = 0; i < s.size(); i++) {
            // 并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
            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) {
                // record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return false;
            }
        }
        // record数组所有元素都为零0，说明字符串s和t是字母异位词
        return true;
    }
};

这种方法做一个数组来记录，更省空间。

题目链接：349. 两个数组的交集

class Solution
{
public:
    vector<int> intersection(vector<int> &nums1, vector<int> &nums2)
    {
        unordered_set<int> record;
        vector<int> result;
        for(int i=0;i<nums1.size();i++){
            record.emplace(nums1[i]);
        }
        for(int i=0;i<nums2.size();i++){
            if(record.find(nums2[i])!=record.end()){
                result.push_back(nums2[i]);
                record.erase(nums2[i]);
            }
        }
        return result;
    }
};

利用哈希集合，先存一个数组进集合，对另一个数组的元素进行查询，如果在集合里，就把元素放进数组，然后在集合里把对应元素删除。

202. 快乐数

class Solution
{
public:
    bool isHappy(int n)
    {
        vector<int> nums;
        unordered_set<int> record;
        int result=0;
        while(result!=1){
            while(n){
                nums.push_back(n%10);
                n/=10;
            }
            result=0;
            for(int i=nums.size()-1;i>=0;i--){
                int multiply=nums[i];
                nums.pop_back();
                result+=multiply*multiply;
            }
            if(record.find(result)!=record.end()) return false;
            record.emplace(result);
            n=result;
        }
        return true;
    }
};

题目说会出现无限循环的情况，那么我们计算记录每个积，只要出现重复的，那么就代表进循环了。

题目链接：1. 两数之和

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

通过哈希表来解决。我们可以知道，数组内元素x，加上哈希表内元素y，结果要等于target。

那么哈希表内元素y=target-x；

我们要做的是，遍历nums，找target-x是否在哈希表里，如果在，那么就解决了。如果不在，那么把x放进哈希表。