代码随想录第六天｜● 哈希表理论基础 ● 242.有效的字母异位词 ● 349. 两个数组的交集 ● 202. 快乐数● 1. 两数之和

状态：好耶！！！！！！！在上形而上学课的时候写leetcode好刺激！

哈希表理论基础 

建议：大家要了解哈希表的内部实现原理，哈希函数，哈希碰撞，以及常见哈希表的区别，数组，set 和map。  

什么时候想到用哈希法，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。  这句话很重要，大家在做哈希表题目都要思考这句话。 

文章讲解：代码随想录

c++容器的底层实现，记一下

" 优先使用unordered_set, 因为查询和增删效率最优。若需要key有序，则用set，然后考虑multi set“ 小tips，先记记

其他的讲了hash 冲突和探测方法。都记得，嘿嘿。

 242.有效的字母异位词 

建议： 这道题目，大家可以感受到 数组 用来做哈希表 给我们带来的遍历之处。 

题目链接/文章讲解/视频讲解： 代码随想录

要点： ascii code转换

fill(vec.begin(), vec.end(), element) 小方法学学，记记

#include <vector>
#include <algorithm>
using namespace std;
class Solution {
public:
    bool isAnagram(string s, string t) {
        vector<int> records(26);
        fill(records.begin(),records.end(),0);
        for(int i = 0; i<s.size();i++){
            size_t hashCode = static_cast<size_t>(s[i]-'a');
            records[hashCode]++;
        }
        for(int i = 0; i<t.size();i++){
            size_t hashCode = static_cast<size_t>(t[i]-'a');
            records[hashCode]--;
        }
        for(int i = 0; i<26; i++){
            if(records[i]!=0) return false;
        }
        // size_t hashCode = static_cast<size_t>(s[0]-'a');
        // cout<<hashCode;
        return true;

    }
};

 349. 两个数组的交集 

无脑做题：

呃呃妹想到吧卡在语法了，动态加元素要用push_back啊啊啊我真的，裤裤。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> results;
        vector<int> dic(1001);
        int index =0;
        for(int i = 0; i<nums1.size(); i++){
            dic[nums1[i]] = 1;
        }

        for(int j = 0; j<nums2.size();j++){
            if(dic[nums2[j]]== 1){
                results.push_back(nums2[j]);
                dic[nums2[j]]= 0;
            }
        }
        return results;
    }
};

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

好好好，我们试试用set

其实就是改了几个点：

unordered_set插入删除

        insert和erase

判断是否存在

        auto 类型， find方法

        返回判断是否为set.end()

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> results;
        unordered_set<int> dict;

        int index =0;
        for(int i = 0; i<nums1.size(); i++){
            dict.insert(nums1[i]);
        }

        for(int j = 0; j<nums2.size();j++){
            auto it = dict.find(nums2[j]);
            if(it!=dict.end()){
                results.push_back(nums2[j]);
                dict.erase(nums2[j]);
            }
        }
        return results;
    }
};

题目链接/文章讲解/视频讲解：代码随想录

看随想录优化一siusiu

增加思路：

1. 数组变set， set变数组类型转换

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> results;
        unordered_set<int> dict(nums1.begin(),nums1.end());

        for(int num: nums2){
            auto it  = dict.find(num);
            if(it != dict.end()){
                results.insert(num);
            }
        }

        return vector<int>(results.begin(),results.end());

    }
};

 202. 快乐数 

建议：这道题目也是set的应用，其实和上一题差不多，就是 套在快乐数一个壳子 

题目链接/文章讲解：代码随想录

套壳题，重点在于发现循环规律。 AC

class Solution {
public:
    int findsum(int n){
        int sum = 0;
        int order = 10;
        while(n/order!=0){
            //cout<<n%order<<endl;
            sum+= (n%order)*(n%order);
            n /=order;
        }
        //cout<<n%order<<endl;
        sum+= (n%order)*(n%order);

        return sum;
    }
    bool isHappy(int n) {
        unordered_set<int> records;
        int record = findsum(n);
        while(record!= 1){
            if(records.find(record)!= records.end()) return false;
            records.insert(record);
            record = findsum(record);
        }
        return true;
    }
};

 1. 两数之和 

来来来来来终于是刷到了leetcode第一题（狗头）

一生二，二生三，三生万物。逐渐发疯哈哈哈哈哈

建议：本题虽然是 力扣第一题，但是还是挺难的，也是 代码随想录中 数组，set之后，使用map解决哈希问题的第一题。 

建议大家先看视频讲解，然后尝试自己写代码，在看文章讲解，加深印象。 

题目链接/文章讲解/视频讲解：代码随想录

AC, 语法不熟

本题学会了:

unordered_map 初始化，插入kv pair。

存（值，索引）的结构可以记记。

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