代码随想录打卡Day5:哈希表

1.242有效的字母异位词

两种方法：

1.用数组的方式来进行比较

由于本题规定了题目中给定的数据范围是小写字母，所以我们可以直接创建26个字母的数组来存储，-'a'来进行转换，那么对应的值就是频数，一个用来加，一个用来减，最后判断对应的一个数组是否全为0，即判断是否是异位词。

2.用哈希表的方式来进行比较

哈希表相对应的使用的范围就更加的广，可以避免内存空间的浪费，比较适合后面的拓展部分的unicode，因为这个对应的范围比较大，如果用第一种方法，由于字符比较稀疏会导致浪费的空间会比较大，用这种的哈希表可以避免大量的内存空间浪费。

unordered_map<char,int> mp;//<字符，频数>这句话是关键，我们需要理解的就是我们在创建hash表的时候，每个部分分被代表什么意思。

class Solution {
public:
    bool isAnagram(string s, string t) {
        int a = s.size();
        int b = t.size();
        if(a!=b){//如果长度不等，那么必然是不是的
            return false;
        }
        /*
        //第一种使用26个字符数组来进行累加，然后来进行比较
        int chs[26];
        for(auto ch:s){
            chs[ch-'a']++;
        }
        for(auto ch:t){
            chs[ch-'a']--;
        }
        for(int i=0;i<26;i++){
            if(chs[i]!=0){
                return false;
            }
        }
        return true;*/
        //第二种情况是用哈希表来存储对应的字符和频数，一个加一个减，再最后遍历这个哈希表是否全为0
        unordered_map<char,int> mp;//<字符，频数>
        for(auto ch:s){
            mp[ch]++;
        }
        for(auto ch:t){
            mp[ch]--;
        }
        for(auto [a,b]:mp){
            if(b!=0){
                return false;
            }
        }
        return true;
    }
};

2.349两个数组的交集

第一种方法类似于前面的第一种方法进行比较，简单，但是空间资源浪费严重。

第二种方法，用哈希表里面的set来进行设置，需要注意的是，set是用来判断是否存在的，map是用来判断数量的，我们需要根据题目的意思来进行操作。

注意：C++使用的是unordered_set和unordered_map而不是hash_set和hash_map，后面两个是个人开发的，前面那两个才是官方的。

初始化的赋值很有借鉴意义。判断集合中是否含有这个元素。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        //两种方法来进行比较
        //第一种使用数组的方式进行比较
        //方法：按照题目给定的范围创造一个nums[1001]的数组
        //遍历nums1给赋值为1，遍历s2，如果nums[nums2[i]]==1，否则不变,那么将其值赋值为2
        //遍历nums[i]，如果对应的值为2的将其添加到vector<int>ret中，返回结果
        //第二种方法：使用unordered_set来进行设置，这样可以避免空间被大量浪费
        unordered_set<int> nums_set(nums1.begin(),nums1.end());//将其值添加进去
        unordered_set<int> result_set;
        for(auto num:nums2){
            if(nums_set.find(num)!=nums_set.end()){//判断集合中是否含有这个元素
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(),result_set.end());
    }
};

3.202快乐数

首先我们得理解快乐数的定义：即将该数替换为一个各位数平方和。

这个里面：我们可以了解到下面说的，如果陷入循环，那么循环分为两种，一种是1，一种是非1，如果最后循环是1代表是快乐数，如果循环不是1，代表的就不是快乐数。

所以我们可以有两种方法来进行解答

1.快慢指针

第一种是用循环的思想：由于这个循环最后一定会进入一个死循环，所以我们可以用到前面的快慢指针的方式（类似环形链表）来判断是否是死循环。具体可以参考. - 力扣（LeetCode）。

class Solution {
public:
    int bitSquareSum(int n) {
        int sum = 0;
        while(n > 0)
        {
            int bit = n % 10;
            sum += bit * bit;
            n = n / 10;
        }
        return sum;
    }
    
    bool isHappy(int n) {
        int slow = n, fast = n;
        do{
            slow = bitSquareSum(slow);
            fast = bitSquareSum(fast);
            fast = bitSquareSum(fast);
        }while(slow != fast);
        
        return slow == 1;
    }
};

2.哈希表

第二种方法就是考虑使用hash表的方式来进行测试，因为题目中给定的最大值是INT_MAX_32,对应的最大2147483647，里面的最大值就是1999999999，此时对应的值为1*1+9*（9*9）=730，所以不论你开始的值为多少，你后面一定会缩小到0~730之间，那么你使用hash表的话，就不会无限的开辟内存空间导致崩溃。

在这个里面我们是先判断其值是否为1,，如果为1，那么就返回true，再判断是否是循环，如果此时是循环（即在hash表中存在），那么一定就不是快乐数。

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()){//找到了循环，此时返回false
                return false;
            }else{
                set.insert(sum);
            }
            n = sum;
        }
    } 
};

4.1两数之和

思路：哈希表来判断是否存在两数之和，由于这个是返回的是对应数值的下标，所以不能直接使用排序，而应该使用hash表来存储值和下标，然后根据对应的target-nums[i]（因为我们此时添加的就是这个i，那么一定存在nums[i]这个值了，我们就只需要判断差值是否存在即可）是否存在即判断里面是否有这个值，如果存在那么代表有这样的两数和，不存在就返回一个无意义的值

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        map<int,int> a;//键值对的hash表key用来存放对应的值，value用于存对应的下标。
        vector<int> b(2,-1);//用来存放结果
        for(int i = 0;i<nums.size();i++){
            if(a.count(target-nums[i])>0){//判断有没有这个key,如果有，则返回一个大于0的值，从而确定存在。
                b[0] = a[target-nums[i]];
                b[1] = i;
                break;
            }
            a[nums[i]] = i;
        }
        return b;
    }
};