算法第6天 242.有效的字母异位词 349. 两个数组的交集 202. 快乐数 1. 两数之和

242.有效的字母异位词

改进卡哥的方法，使用一个判断先判别数组长度是否相等，不相等一定是false
相等再进行下一步判断

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

349. 两个数组的交集

这道题我想着就是使用数组或者vector去做，听到卡哥讲解才了解到set里面的一些关键点，下面是卡哥的描述，明天可以按照set的方式再做一遍

建议：本题就开始考虑 什么时候用set 什么时候用数组，本题其实是使用set的好题，但是后来力扣改了题目描述和 测试用例，添加了 0 <= nums1[i], nums2[i] <= 1000 条件，所以使用数组也可以了，不过建议大家忽略这个条件。 尝试去使用set。

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

202. 快乐数

这里为何会想到使用哈希表进行解答呢？

在题目中有说到会无限循环，因此如果将计算得到的sum存放在一个哈希表中，每次运算之后就搜索这个哈希表，如果运算后得到的新的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;
            }
            // 如果这个sum曾经出现过，说明已经陷入了无限循环了，立刻return false
            if (set.find(sum) != set.end()) {
                return false;
            } else {
                set.insert(sum);
            }
            n = sum;
        }
    }
};

1. 两数之和

这里的解题思路是当然可以两层循环暴力解法，但是时间复杂度为O(n2)

这里同样涉及到查找，因此可以通过遍历表，查找表之前是否出现target-nums[i]这个元素，由于这里涉及到下表，所以可以使用unordered_map来存储

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