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

1-文章和视频链接

1.1 242.有效的字母异位词-代码随想录
1.2 242.有效的字母异位词-卡哥B站视频讲解
1.3 349.两个数组的交集-代码随想录
1.4 349.两个数组的交集-卡哥B站视频讲解
1.5 202.快乐数-代码随想录
1.6 1.两数之和-代码随想录
1.7 1.两数之和-卡哥B站视频讲解

---

2-题目

第一题：242.有效的字母异位词

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = {0};             // 定义一个长26的数组，初始值全为0
        for(int i=0; i<s.size(); i++){    // 遍历s字符串
            record[s[i] - 'a']++;         // s字符串中第i个字母与‘a’的差值，就是数组的位置
        }                                 // 因为字母ASCII码是连续的。该字母出现次数+1

        for(int i=0; i<t.size(); i++){    // 遍历t字符串
            record[t[i] - 'a']--;         // t字符串中第i个字母出现，数组对应位置的值-1
        }

        for(int i=0; i<26; i++){          // 遍历数组
            if(record[i]!=0){             // 一旦数组中任何位置的值不为0
                return false;             // 就不是字母异位词
            }
        }

        return true;                      // 全都是0，则s和t是字母异位词
    }
};

• 思路： 暴力解法就是两个循环嵌套。低时间复杂度的解法是定义一个26字母长度的数组，遍历s字符串，出现了哪个字母，对应的数组位置上的值加1；再遍历t字符串，出现了哪个字母，对应的数组位置上的值减1。最后只要确认数组内元素的值是否都为0即可。
• 实现难点： 将字符串中某位字母与字母‘a’相减的差值，作为数组中元素的位置值。
• 收获： 数组作为哈希表很简便。

第二题：349.两个数组的交集

<1> 用set解题

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;        // 定义一个结果set，用unordered_set直接去重
        // 将vector形式的nums1通过begin，end遍历其中每个数，转换成unordered_set，去重
        unordered_set<int> nums_set(nums1.begin(), nums1.end());

        for(int num : nums2){   // nums2中每个数遍历
            // 将unordered_set形式的nums1中的数去查nums2中有没有
            // find的用法是如果没有查到num，则返回end
            // 所以只要查询的返回不是end，就是2个数组的交集
            if(nums_set.find(num)!=nums_set.end())  
                result_set.insert(num);             // 在结果set中插入找到的相同元素
        }

        // 将unordered_set形式的结果转换成vector形式并返回
        return vector<int>(result_set.begin(), result_set.end());
    }
};

<2> 用数组解题

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;    // 定义一个结果set,unordered_set可以直接去重
        int hash[1001] = {0};             // 定义一个比1000-稍大的哈希列表，初始化元素都为0

        for(int num : nums1){             // 遍历数组nums1
            hash[num] = 1;                // 对nums1中出现的元素设为1，没出现的还是初始值0
        }

        for(int num : nums2){             // 遍历数组nums2
            if(hash[num]==1)              // 若nums2中出现元素是1，说明该元素2个数组中都有
                result_set.insert(num);   // 在结果set中插入相交的元素
        }

        // 将结果set转换成结果数组并返回
        return vector<int>(result_set.begin(), result_set.end());
    }
};

• 思路： 数组1转换成unordered_set形式，可以直接去重，再将数组2中的元素和set形式的数组1中元素比较，求出交集。
• 实现难点： find函数的返回会弄错，!=会写成==。
• 收获： set的find返回原先一直不知道，联系后发现与之前理解不一致，find如果没有查询到，返回的是end，而不是-1。还有，在元素比较稀疏的时候，不适合使用数组解法，因为要开一个很大的数组，但空间很多都浪费了。unordered_set的选择可以直接去重。

第三题：202.快乐数

class Solution {
public:
    int getSum(int n){                    // 定义函数计算一个数每个位置上的平方和
        int sum = 0;                      // 定义总和为0
        while(n){                         // 在位数不为0时候循环加法
            sum += (n % 10) * (n % 10);   // 一个位上的数字的平方，加到之前位的总和中
            n /= 10;                      // 下一高位
        }
        return sum;                       // 返回一个数的每位平方和
    }

    bool isHappy(int n) {                 // 判断是否是开心数的函数
        unordered_set<int> set;           // 定义一个unordered_set
        while(1){                         // 无限循环
            int sum = getSum(n);          // 得到返回的平方和
            if(sum==1) return true;       // 如果总和是1，直接返回true，1无限循环后还是1
            // 如果总和之前出现过，注意此处的总和已经经过前一个判断不为1
            // 将会无限循环至不是1的总和，直接返回false
            if(set.find(sum)!=set.end()) return false;
            else set.insert(sum);          // 总和在哈希表中没出现过，则插入
            n = sum;                       // 下一轮检测的数是平方和的结果
        }
    }
};

• 思路： 如果总和无限循环为1，就是开心数，如果总和无限循环为一个不为1的数，则不是开心数。
• 实现难点： 对一个数字的每一位上求平方然后加和；判断条件的优先顺序，要先判断总和为1的true条件然后再判断总和是否无限循环且不为1。
• 收获： 位数求总和；哈希表在判断一个元素是否出现时应该被使用。

第四题：1.两数之和

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map<int, int> map;          // 定义unordered_map
        for(int i=0; i<nums.size(); i++){          // 遍历数组
            // 定义一个键值对，是要找的值及其序号
            // 要找的数是目标值减去数组中当前的第i个数值
            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中key存放的是数组中遍历过的元素，value存放的是对应的元素序号；键值对中first，second分别代表key和value；返回时是两个元素的序号，插入时是一对键值对。
• 收获： map的使用方法和何时使用。