算法学习Day6 | Chapter3哈希表

3.1 哈希表理论基础

链接：文章

1. 哈希表是根据关键码的值而直接进行访问的数据结构。

2. 一般哈希表是用来快速判断一个元素是否出现集合里。

3. 哈希函数 hash function

4. 哈希碰撞（hash collision）解决方法：

（1）拉链法：将发生冲突的元素存储在链表中

（2）线性探测法：将发生冲突的元素存储在哈希表中的空位中

5. 常见的三种哈希结构：数组，set(集合)，map(映射)。

6. 哈希法牺牲了空间换取了时间。

3.2 有效的字母异位词

链接：文章；视频；242.有效的字母异位词

class Solution {
public:
    bool 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;
    }
};

3.3 两个数组的交集

链接：文章；视频；349.两个数组的交集

1. 数组（哈希值范围小可选）

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

2. set（如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费）

其中，std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表，使用unordered_set在取值和查找时效率是最高的，并不需要对数据进行排序，而且还不会让数据重复

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result;
        unordered_set<int> nums(nums1.begin(), nums1.end()); // 将nums1存入set
        for (int num : nums2) { // 遍历nums2
            if (nums.find(num) != nums.end()) { // find不到与end()返回一致的迭代器
                result.insert(num);
            }
        }
        return vector<int>(result.begin(), result.end());
    }
};

3.4 快乐数

链接：文章；202.快乐数

解题关键：平方和无限循环为非快乐数，这个数将重复出现。

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;
        int sum;
        while (1) {
            sum = getSum(n);
            if (sum == 1) {
                return true;
            }
            if (set.find(sum) != set.end()) { //如果sum曾出现过，说明已经陷入了无限循环
                return false;
            } else {
                set.insert(sum);
            }
            n = sum; 
        }
    }
};

3.5 两数之和

链接：文章；视频；1.两数之和

解题关键：不仅要知道元素有没有遍历过，还有知道这个元素对应的下标，所以用map。

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 num = target - nums[i];
            if (map.find(num) != map.end()) {
                return {i, map.find(num)->second};
            } else { // 如果没找到匹配对，就把访问过的元素和下标加入到map中
                map.insert(pair<int, int>(nums[i], i));
            }
        }
        return {};
    }
};