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

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

[242-题目链接](. - 力扣（LeetCode）)

解题状态：已通过

题目描述：给定两个字符串 s 和 t ，编写一个函数来判断 s 是否是 t的字母异位词。

**注意：**若 **s** 和 *t* 中每个字符出现的次数都相同，则称 *s* 和 *t* 互为字母异位词。

我的解答：

#include <iostream>
using namespace std;
#include <unordered_map>

class Solution {
public:
    bool isAnagram(string s, string t) 
    {
        if(s.size() != t.size())
        {
            return false;
        }
        unordered_map<char, int> hash_table1;
        unordered_map<char, int> hash_table2;
        string::iterator it1 = s.begin();
        while(it1 != s.end())
        {
            hash_table1[*it1]++;
            ++it1;
        }
        string::iterator it2 = t.begin();
        while(it2 != t.end())
        {
            hash_table2[*it2]++;
            ++it2;
        }
        string::iterator it3 = s.begin();
        while(it3 != s.end())
        {
            if(hash_table1[*it3]!=hash_table2[*it3])
            {
                return false;
            }
            it3++;
        }
        return true;
    }
};

解题思路：我的办法是比较笨的方法，直接创建两个hash表，分别记录s和t中每个字符出现的次数，然后再对s或t出现的字符进行判断，看它在两个字符串中出现的次数是否一致。

代码随想录题解：

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

解题思路：使用数组来充当hash表，需要把字符映射到数组也就是哈希表的索引下标上，因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。在遍历字符串s的时候，只需要将 以【s[i] - ‘a’】作为哈希函数，求出索引位置， 做+1 操作即可，统计该字符的个数。然后，在遍历t字符串的时候，同样以【s[i] - ‘a’】作为哈希函数，求出索引位置， 但做的是减1操作。最后我们检查数组，如果全部位置都为0，说明满足了题目条件，否则不满足。

[题目解析](代码随想录 (programmercarl.com))

视频解析

[349-题目链接](349. 两个数组的交集 - 力扣（LeetCode）)

解题状态：已通过

题目描述：给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

我的解答：

#include <iostream>
using namespace std;
#include <unordered_map>

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) 
    {
         unordered_map<int, int> hash_table1;
         vector<int> res;
         vector<int>::iterator it1 = nums1.begin();
         while(it1 != nums1.end())
         {
             if(hash_table1.find(*it1) == hash_table1.end())
             {
                 hash_table1[*it1]++;
             }
             it1++;
         }
         for(int i=0;i<nums2.size();i++)
         {
             if(hash_table1.find(nums2[i])!=hash_table1.end() && count(res.begin(),res.end(),nums2[i])==0)
             {
                 res.push_back(nums2[i]);
             }
         }
         return res;

    }
};

解题思路：首先创建一个hash表，用于统计数组nums1中出现了哪些数字，然后再遍历数组nums2,并通过hash表判断nums1中是否有相同的数字，把共有的数字存入返回的vector里。

代码随想录题解：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        unordered_set<int> nums_set(nums1.begin(), nums1.end());
        for (int num : nums2) {
            // 发现nums2的元素 在nums_set里又出现过
            if (nums_set.find(num) != nums_set.end()) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

解题思路与我的类似，只是这里使用的工具是unordered_set。

[题目解析](代码随想录 (programmercarl.com))

[视频解析](学透哈希表，set使用有技巧！Leetcode：349. 两个数组的交集_哔哩哔哩_bilibili)

[202-题目链接](202. 快乐数 - 力扣（LeetCode）)

解题状态:已通过

题目描述：

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
• 如果这个过程 结果为 1，那么这个数就是快乐数。

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

我的解答：

class Solution {
public:
    bool isHappy(int n) 
    {
        vector<int> res;
        int sum;
        sum = get_sum(n);
        while(count(res.begin(),res.end(),sum)==0 && sum!=1)
        {
            res.push_back(sum);
            sum = get_sum(sum);
        }
        if(sum==1)
        {
            return true;
        }
        return false;
    }

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

解题思路：

首先编写一个函数【get_sum】用于计算每位的平方和，同时用一个vector存储函数的返回值，如果遇到的值是从未出现过的，就把它存入vector里，如果曾经出现过，就说明这个数不是【快乐数】，不管计算多少次，都会再次回到这个数，只有当【get_sum】返回的sum值等于1时，才返回true。

代码随想录题解：

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;
            }
            // 如果这个sum曾经出现过，说明已经陷入了无限循环了，立刻return false
            if (set.find(sum) != set.end()) {
                return false;
            } else {
                set.insert(sum);
            }
            n = sum;
        }
    }
};

解题思路和我的一样，只是题解用了set工具。

[题目解析](代码随想录 (programmercarl.com))

本题无视频讲解

[1-题目链接](1. 两数之和 - 力扣（LeetCode）)

解题状态：已通过

题目描述：给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。

我的解答：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        vector<int> res;
        for(int i=0;i<nums.size();i++)
        {
            int other = target-nums[i];
            vector<int>::iterator j;
            j=find(nums.begin(),nums.end(),other);
            if(j!=nums.end() && (j-nums.begin())!=i)
            {
                res.push_back(i);
                res.push_back(j-nums.begin());
                return res;
            }
        }
        return res;
    }
};

解题思路：我直接遍历了数组，用目标值减去当前遍历的值，再去数组里找这个差值，得到差值的索引，返回结果。

代码随想录题解：

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

解题思路：

题解采用了map，在遍历数组时，判断目标和当前元素的差值是否在map里，如果在的话，就返回他们的下标（存在Map的value中），如果查找失败，就把当前元素存入map的key，并把它的索引作为map的value存起来。当遍历的时候，对于差值的查找成功，就说明找到了符合题意的两个元素。其实思路和我的解答是一样的，只是代码的实现方式有区别。

[题目解析](代码随想录 (programmercarl.com))

视频解析