代码随想录day6 | 哈希表 | 有效字母异位词、两个数组的交集、快乐数、两数之和

卡哥题目来源

有效字母异位词

关键点
因为26个字母限制死了数组大小，因此用数组就最快

1. 用数组来存储出现的次数
2. 判断第一次用加，判断第二次用减
3. 最后统计record数组是否为0
   我的代码

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

    }
};

卡哥的代码

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;
    }
};

两个数组的交集

主要是学会哈希表，有点像是用哈希表的api

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

快乐数

非快乐数会陷入无限循环，这是因为对于非快乐数来说，重复计算每个数位的平方和最终会导致某些特定数值重复出现，形成一个循环。这种循环会导致我们永远无法得到结果 1，而是不断地在循环中循环。
快乐数和非快乐数

快乐数：经过一系列对每个数位的平方和的计算，最终可以得到 1。例如，19 是快乐数，因为 19 -> 82 -> 68 -> 100 -> 1。
非快乐数：经过一系列对每个数位的平方和的计算，不会得到 1，而是会进入一个循环。例如，4 是非快乐数，因为 4 -> 16 -> 37 -> 58 -> 89 -> 145 -> 42 -> 20 -> 4 形成了一个循环。

题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现，这对解题很重要！
当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。

所以这道题目使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false， 否则一直找到sum为1为止。

判断sum是否重复出现就可以使用unordered_set。
我的代码

class Solution {
public:
    int getSum(int n)
    {
        int sum = 0;
        while(n)
        {
            sum += (n%10) * (n%10);
            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;
        }
    }
};

两数之和

关键点
用只需要遍历一遍的方式来实现寻找两个下标，由于是两数之和，因此破局是target - nums[i]，只需要在之前走过的历史数据中寻找是否存在当前指针指向的差值，而之前走过的历史数据用map哈希表来存储key和 value
我的代码

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