代码随想录算法训练营43期 | Day 6——哈希表Part01

常见的三种哈希结构

• 数组
• （set）集合
• （map）映射

set

unordered_set 底层实现是哈希表，std::set 和std::multiset 的底层实现是红黑树，红黑树是一种平衡二叉搜索树，所以key值是有序的，但key不可以修改，改动key值会导致整棵树的错乱，所以只能删除和增加。

map

std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。同理，std::map 和std::multimap 的key也是有序的

当我们要使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset。

那么再来看一下map ，在map 是一个key value 的数据结构，map中，对key是有限制，对value没有限制的，因为key的存储方式使用红黑树实现的。

总结：
当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法，但是哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。

242.有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词
示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true
示例 2: 输入: s = “rat”, t = “car” 输出: false

解题思路

哈希法：
1.利用数组来记录字母出现的次数record；
2. 再检查字母t中是否出现s的字母，对字符映射的哈希表数组下标对应数值-1；
3. 最后，检查记录出现次数的数组record，是否全为1；

bool isAnagram(string s, string t) {
        //哈希法 利用数组来记录字母出现的次数
        //1. 定义数组长度 26 ,初始值全为0
        int record[26]={0};
        //2. 遍历s
        for(int i = 0;i < s.size();i++)
        {
            //record数组，记录s数组每个字母出现的次数
            record[s[i]-'a']++;
        }
        //3. 遍历t，t中字母出现则在record数组中对应下边的元素-1
        for(int j = 0; j < t.size(); j++)
        {
            record[t[j]-'a']--;
        }
        
        //4. 判断record数组是否全是0，全是0返回true，否则返回false
        for(int i = 0;i < 26;i++)
        {
            if(record[i]!=0)
            {
                return false;
            }
        }
        return true;
    }

349. 两个数组的交集

给定两个数组，编写一个函数来计算它们的交集。

解题思路

哈希法：
unordered_set
输出结果中的每个元素一定是唯一的，也就是说输出的结果的去重的， 同时可以不考虑输出结果的顺序

vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;
        unordered_set<int> num_set(nums1.begin(),nums1.end());
        for(int num:nums2)
        {
            if(num_set.find(num)!=num_set.end())
            {
                result_set.insert(num);
            }
        }
        return vector<int> (result_set.begin(),result_set.end());
    }

    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        //定义一个哈希表 unordered_set,nums 存储,result_set无重复元素
        unordered_set<int> result_set(nums2.begin(), nums2.end());
        //定义数组，用于存储nums2中元素出现的次数
        vector<int> nums;
        //遍历nums1
        for(int num:nums1)
        {
            if(result_set.find(num)!=result_set.end())
            {
                result_set.erase(num);
                nums.emplace_back(num);
            }
        }
        return nums;
    }

202. 快乐数

编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。
如果 n 是快乐数就返回 True ；不是，则返回 False 。

class Solution {
public:
    int getsum(int n)
    {
        int sum = 0;
        while(n)
        {
            sum += (n % 10) * (n % 10);
            n = 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;
        }

    }
};

1. 两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

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