代码随想录算法训练营|有效的字母异位词， 两个数组的交集，两数之和， 快乐数

哈希表

242.有效的字母异位词

我们知道二十六个英文字母的ASCII是二十六个连续的数值，那么b的ASCII和a相差就是1，我们可以根据这个来建造一个哈希表，在这里的哈希表其实就是数组，有二十六个英文字母，那么就创造大小为26的数组 record。

那么让每个字母减去’a’得到的值作为下标保存到数组当中，例如 record[1] 中记录的就是b这个字母出现的个数，每出现一次，对应下标的值加一。

当遍历完第一个字符串之后，数组当中就记录了每个字母出现的个数，遍历第二个字符串的时候，出现一个字母，就让原数组对应下标的元素减一即可。
也就是说如果这两个是符合题目条件的字符串，那么最后数组的所有元素都为0，思路就是这样。

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. 两个数组的交集

由于题目返回的值没有重复的，所以可以选择 unordered_set 。
思路非常简单，就是将其中一个数组的元素放到一个哈希表中，然后遍历第二个元素，看有没有相等的元素。
然后将符合的值放到另一个哈希表中，最后返回这个哈希表就好。

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

第202题. 快乐数

根据题意，我们需要对多个数进行题目给定的操作，即：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。所以我们可以先构造一个函数。

int getsum(int n){
        int sum = 0;
        while(n){
            sum += (n%10) * (n%10);
            n /= 10;
        }
        return sum;
    }

在此过程中，有可能会出现无限循环的情况，那怎么样会出现这种情况呢？

假如第一次出现了一个数n，再循环一段时间之后，又出现了这个n，那么这就会无限循环，因为永远也无法出现1。（永远也无法到达的真实）

那么判断是否出现重复的数，首先就可以考虑哈希表，我们将出现的数都放在哈希表中，然后进行查找就好了。

主函数如下

bool isHappy(int n) {
       unordered_set<int> set;
       while(1){
           int c = getsum(n);
           if(c == 1){
               return true;
           }
           if(set.find(c) != set.end()){
               return false;
           }
           else{
               set.insert(c);
           }
           n = c;
       }

l.两数之和

根据题意,我们不仅仅要知道元素有没有遍历过，还需要知道元素对应的下标,所以我们需要 key-value 结构来储存,用 key 来储存元素, 用 value 来储存下标,因为我们需要通过key来找到value ,那么我们创建一个map即可。

那这道题的思路就很简单了，每次遍历数组的时候，我们可以再map里面寻找符合题意的值，如果没有，就把目前遍历的值放到map里面。

需要注意的是，我们需要一个迭代器来帮助我们完成这个操作，我们将迭代器命名为iter
我们需要 iter 来访问value的值。

for(int i = 0; i < nums.size(); i++) {
            // 遍历当前元素，并在map中寻找是否有匹配的key
            auto iter = map.find(target - nums[i]); 
            if(iter != map.end()) {
                return {iter->second, i};
            }
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int, int>(nums[i], i)); 
        }

其中

auto iter = map.find(target - nums[i]); 
            if(iter != map.end()) {
                return {iter->second, i};
            }

这段的作用是来查找有没有符合的值，如果找到了，就返回value和i，其中的value就是值。
没有的话就放到map当中，如下
map.insert(pair<int, int>(nums[i], i));
完整代码：

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++) {
            // 遍历当前元素，并在map中寻找是否有匹配的key
            auto iter = map.find(target - nums[i]); 
            if(iter != map.end()) {
                return {iter->second, i};
            }
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int, int>(nums[i], i)); 
        }
        return {};
    }
};