哈希表 | 哈希表基础

哈希表理论基础

什么时候想到用哈希法（散列表）?
当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

特点：

• 快速存取
• 空间换时间

使用数组和set来做哈希法的局限:

• 数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
• set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用。

题目链接：

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

242.有效的字母异位词

参考：代码随想录

class Solution {
public:
    int isAnagram(string s, string t) {
        // 数组作为哈希表
        int hash[26]={0};
        for(int i=0; i<s.size(); i++){
            hash[s[i]-'a']++;
        }
        for(int j=0;j<t.size();j++){
            hash[t[j]-'a']--;
        }
        for(int k=0;k<26;k++){
            if(hash[k]!=0){
                return false;
            }
        }
        return true;
    }
};

349. 两个数组的交集

参考：学透哈希表，set使用有技巧！Leetcode：349. 两个数组的交集

unordered_set

关于set，C++ 给提供了如下三种可用的数据结构：

• std::set
• std::multiset
• std::unordered_set
  在内部，元素不按任何特定顺序排序，而是组织到桶中。元素被放入哪个桶完全取决于其值的散列。这允许快速访问单个元素，因为一旦计算出哈希值，它就会指向元素放入的确切桶。
  unordered_set 容器和 set 容器很像，唯一的区别就在于 set 容器会自行对存储的数据进行排序，而 unordered_set 容器不会
  总的来说，unordered_set 容器具有以下几个特性：
  不再以键值对的形式存储数据，而是直接存储数据的值；
  容器内部存储的各个元素的值都互不相等，且不能被修改。
  不会对内部存储的数据进行排序

std::set和std::multiset底层实现都是红黑树， std::unordered_set的底层实现是哈希表， 使用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。

针对代码中：判断nums2的元素 在nums_set里又出现过的代码
if (nums_set.find(num) != nums_set.end()) { result_set.insert(num);}
可以看： C++ STL 中的 unordered_set find() 函数
意思是：在容器中搜索元素。它返回一个指向该元素的迭代器，如果找到其他元素，它返回一个指向 unordered_set::end() 的迭代器。

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());//把num1转化为unordered_set形式
        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());
    }
};

承接上一题的思路，很容易想到还是用数组构造哈希表的想法。
受给出的例子的影响，以为num1和num2都是小于10的数，所以给定hash[ ]数组划定空间较小，没有AC通过。参考力扣数值范围：1 <= nums1.length, nums2.length <= 1000, 可以把hash[ ]数组范围改大为大于1000的数。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; 		// 存放结果，之所以用set是为了给结果集去重
        int hash[1005] = {0}; 				// 默认数值为0
        for (int num : nums1) { 			// nums1中出现的字母在hash数组中做记录
            hash[num] = 1;
        }
        for (int num : nums2) { 			// nums2中出现的话，result记录
            if (hash[num] == 1) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};
//记录一下我的笨办法以下次刷题时提高：
//构造两个hash[1001]和hash2[1001]
//然后hash[num1[i]]++后，判断hash[num1[i]]是否大于1，是则置于1；
//最后，对比公共交集也是hash[i]==1 & hash2[i]==1

202. 快乐数

第一次见的想法是，最后各数平方和一定要是10的倍数，或者直接只有1。当成数学题了。

这道题目看上去貌似一道数学问题，其实并不是！
题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现，这对解题很重要！

循环->当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。

使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false， 否则一直找到sum为1为止。
判断sum是否重复出现就可以使用unordered_set。

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;
            }
            // 关键👇： 在循环里出现过，set就是无序的暂时保管结果的仓库
            // 如果这个sum曾经出现过，说明已经陷入了无限循环了，立刻return false
            if (set.find(sum) != set.end()) {
                return false;
            } else {
                set.insert(sum);
            }
            n = sum;
        }
    }
};

1. 两数之和

需要：

• 一个集合来存放我们遍历过的元素，
• 然后在遍历数组的时候去询问这个集合，
• 某元素是否遍历过，也就是 是否出现在这个集合。

使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适

基础操作

参考：C++中的unordered_map用法详解

unordered_map<string, int> umap; //定义
//map中查找x是否存在
umap.find(x) != map.end()//查
//或者
umap.count(x) != 0

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}; //因为要求的结果是两个数的索引，所以输出的是索引
                //iter.first会得到key，
                //iter.second会得到value。
            }
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int, int>(nums[i], i)); 
        }
        return {};
    }
};