代码随想录算法训练营day06

题目：242.有效的字母异位词、349. 两个数组的交集、202. 快乐数、1. 两数之和

参考链接：代码随想录

242.有效的字母异位词

思路：首先是暴力算法，思路是对s，遍历每个字符，对每个字符的出现次数还需要记录，然后再遍历t，一个一个比，时间复杂度O(n^2)。使用哈希表可以记录s中每个字母出现的次数，本题可以使用数组作为哈希表，长度26，即记录a-z每个字符出现的次数，在遍历s的时候完成第一遍记录，然后遍历t，如果出现则讲记录减少，最后检验记录数组（哈希表）是否全为0，时间复杂度O(n)。

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

349. 两个数组的交集

思路：本题数组的元素是不确定的，不像上题最多只有26个，因此使用数组做哈希表并不合适，这题涉及到去重，最适合的数据结构是unordered_set,底层是哈希表。方法是直接将nums1存入集合中去重，然后在nums2中到集合中查询，如果查到就是结果，将结果先保存在集合中去重，然后返回vector，时间复杂度O(n)。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> n1,n2;
        vector<int> ans;
        for(int i=0;i<nums1.size();i++){
            n1.insert(nums1[i]);
        }
        for(int i=0;i<nums2.size();i++){
            if(n1.find(nums2[i])!=n1.end()){//在n1中找nums2中元素
                n2.insert(nums2[i]);
            }
        }
        for(int i:n2){//C11新方法遍历集合
            ans.push_back(i);
        }
        return ans;
    }
};

看标答，主要是可以快速使用C++的类型转换，我这个不够熟练，多写了许多代码。

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<int> nums_set(nums1.begin(), nums1.end())和vector<int>(result_set.begin(), result_set.end())的快速类型转换我以前没用过。

202. 快乐数

思路：本题我想了很久也没有思路，只会暴力算，主要问题在于我不知道如何联想到哈希表中。看了提示发现由于sum会出现循环，即重复出现，那么可以使用哈希表来判断一个元素的重复出现。而sum的重复出现，由于sum的大小不固定，使用数组不合适，因此我们还是使用unordered_set。时间复杂度O(logn)。

class Solution {
public:
    int getSum(int n){
        int sum=0;
        int tmp;
        while(n){
            tmp=n%10;
            sum+=(tmp*tmp);
            n=n/10;
        }
        return sum;
    }
    bool isHappy(int n) {
        unordered_set<int> ans;
        while(ans.find(n)==ans.end()){//哈希表中找不到n，说明还没有出现重复
            if(n==1){
                return true;
            }
            ans.insert(n);
            n=getSum(n);
        }
        return false;
    }
};

我的写法比标答还要简洁一些。

1. 两数之和

思路：暴力算法两次遍历，时间复杂的O(n)。使用哈希表，在遍历过程中，如果target-i不在表中，则说明没有找到结果，将遍历项存入表中，如果找到结果就返回。由于本题需要返回数组下标，因此需要使用unordered_map()，底层实现为哈希表。时间复杂度O(n)。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> mp;
        for(int i=0;i<nums.size();i++){
            if(mp.find(target-nums[i])!=mp.end()){//找到答案
                return vector<int> {i,mp[target-nums[i]]};//可以以这种形式返回
            }
            mp[nums[i]]=i;
        }
        return vector<int> {};
    }
};

标答将找到的结果保存为iter，在后续返回的时候就不需要再查一遍，更简洁，而且return{}默认就是vector<int>，不用再加。
标答：

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