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

LeetCode 242 有效字母的异位词

题目链接：242. 有效字母的异位词

做题情况：由于题目出现在哈希表章节，所以第一反应就想到了用哈希法，然后看了相关知识点和一些哈希数据结构常用函数接口，然后自己ac出来了，下面是自己的ac代码：

class Solution {
public:
    bool isAnagram(string s, string t) {
        int n1=s.size();
        int n2=t.size();
        unordered_map<char,int>hash;
        for(int i=0;i<n1;i++){
            if(hash.find(s[i])==hash.end()){//注意此处的写法，当时自己第一次写出错了
                hash[s[i]] =1;
            }else{
                hash[s[i]] +=1;
            }    
        }
        //或者
        //for(int i=0;i<n1;i++){
        //    hash[s[i]] +=1;  
        //}
        for(int j=0;j<n2;j++){
            if(hash.find(t[j])==hash.end()){//这里面都是t[j]哦，得细心，当时自己第一次写出错了
                return false;
            }else{
                hash[t[j]]-=1;
            }
        }
        for(unordered_map<char,int>::iterator it=hash.begin();it!=hash.end();it++){
            if(it->second!=0){
                return false;
            }
        }
        
        return true;
    }
};

当时自己直接用了 unordered_map数据结构，但是看了卡哥视频和代码随想录书相关部分，才知道需要用数组当作一个简单哈希表即可，而且最终写出了的代码并没有上述那么冗余和显得不专业，感觉自己写的在大才小用，具体代码如下：

class Solution {
public:
    bool isAnagram(string s, string t) {
        int hash[26]={0};//注意这里面初始化数组所有为0的方法
        for(int i=0;i<s.size();i++){
            hash[s[i]-'a']++;
        }
        for(int i=0;i<t.size();i++){
             hash[t[i]-'a']--;
        }
        for(int i=0;i<26;i++){
            if(hash[i]!=0)return false;
        }
        return true;
    }
};

LeetCode 349 两个数组的交集

题目链接：349. 两个数组的交集

做题情况：这道题目还算简单，独立做时候当时用的unordered_set数据结构，自己具体ac代码：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int>res;
        unordered_set<int>set;
        int n1=nums1.size();
        int n2=nums2.size();
        for(int i=0;i<n1;i++){
            set.insert(nums1[i]);
        }
        for(int j=0;j<n2;j++){
            if(set.find(nums2[j])!=set.end()&&find(res.begin(),res.end(),nums2[j])==res.end()){//注意输出结果每个元素都是唯一的，此处也可以继续用unordered_set来达到去重目的
                res.push_back(nums2[j]);
            }
        }
        return res;
    }
};

看完卡哥视频和代码随想录书相关部分，才知道本题目还有那么多细节自己不知道，具体如下：①由于此题目数值的大小限制在[0, 1000]内，所以可以用数组作为简单的哈希表更好 ② set数据结构当用在数值范围不确定或者哈希值比较少、很分散、跨度非常大的情况下使用更好③ 注意去重，比如用上述的unordered_set数据结构来达到去重目的，后面重新ac两段代码如下：

//使用unordered_set
class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int>result;
        unordered_set<int>numset(nums1.begin(),nums1.end());
        for(int num:nums2){
            if(numset.find(num)!=numset.end()){
                result.insert(num);
            }
        }
        return vector(result.begin(),result.end());
    }
};

//使用数组
class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int>result;
        int hash[1005]={0};
        for(int i=0;i<nums1.size();i++){
            hash[nums1[i]]=1;
        }
        for(int i=0;i<nums2.size();i++){
            if(hash[nums2[i]]==1){
                result.insert(nums2[i]);
            }
        }
        return vector<int>(result.begin(),result.end());
    }
};

LeetCode 202 快乐数

题目链接：202. 快乐数

做题情况：这道题目没有做出来也没有思路，当时看到思路就很混乱，觉得很难的样子，看完相关讲解后，发现本题目也不难，主要有以下几个点：① 咋样取数值各个位上的单数操作 ② 无限循环的情况是求和的过程中，sum会重复出现，这就可以使用unordered_set，具体ac代码如下：

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;
            }
            if(set.find(sum)!=set.end()){
                return false;
            }else{
                set.insert(sum);
            }
            n=sum;
        }
    }
};

LeetCode 1 两数之和

题目链接：1. 两数之和

做题情况：由于本题以前做过，所以本次又用暴力和哈希法给重新做了一遍，两种方法具体ac代码如下：

//暴力解法
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int n=nums.size();
        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){//注意不能取相同的下标
                if(nums[i]+nums[j]==target){
                    return {i, j};
                }
            }
        }
        return {};
    }
};

//哈希解法
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int n=nums.size();
        unordered_map<int,int>hash;
        for(int i=0;i<n;i++){
            hash[nums[i]]=i;
        }
        for(int j=0;j<n;j++){
            if(hash.find(target-nums[j])!=hash.end()&&j!=hash.find(target-nums[j])->second){//注意不能取相同的下标
                return {j,hash.find(target-nums[j])->second};
            }
        }
        return {};
    }
};

上述自己用的哈希法代码和卡哥所给的代码还是有很大不同的，感觉总是那么不专业和冗余（自己两次循环遍历和判断相同的下标方法感觉好low），具体代码如下：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int>map;
        for(int i=0;i<nums.size();i++){
            int s=target-nums[i];
            unordered_map<int,int>::iterator iter=map.find(s);
            if(iter!=map.end()){
                return {i,iter->second};
            }
            map.insert({nums[i],i});
        }
        return {};
    }
};

今天题目相对简单，没有很复杂晦涩难懂的思想，关键还是这几种数据结构，自己独立做题和看相应知识点讲解等，所有做下来以及写博客共花了四个小时左右

贵在坚持，加油，共勉