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

哈希表理论基础

文章链接：https://programmercarl.com/%E5%93%88%E5%B8%8C%E8%A1%A8%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html

使用场景：需要快速判断一个元素是否出现在集合里，O(1)

定义：

• 哈希表——是根据关键码的值而直接进行访问的数据结构；哈希表 == 散列表; 数组就是一张哈希表；哈希表中关键码就是数组的索引下标，然后通过下标直接访问数组中的元素

• 哈希函数——将元素映射到哈希表上

• 哈希碰撞——元素映射到同一下标上——1. 拉链法 2.线性探测法

• 拉链法：

• 线性探测法：一定要保证tableSize大于dataSize

• 常见的三种哈希结构：

  • 数组

  • set （集合）：

    • std::set 和std::multiset 的底层实现是红黑树，红黑树是一种平衡二叉搜索树，所以key值是有序的，但key不可以修改，改动key值会导致整棵树的错乱，所以只能删除和增加
    • std::unordered_set底层实现为哈希表
    • 当我们要使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset

  • map(映射)：

    • std::map 和std::multimap 的底层实现是红黑树。同理，std::map 和std::multimap 的key也是有序的
    • std::unordered_map 底层实现为哈希表
    • 在map 是一个key value 的数据结构，map中，对key是有限制，对value没有限制的，因为key的存储方式使用红黑树实现的

  • 虽然std::set、std::multiset 的底层实现是红黑树，不是哈希表，但是std::set、std::multiset 依然使用哈希函数来做映射，只不过底层的符号表使用了红黑树来存储数据，所以使用这些数据结构来解决映射问题的方法，我们依然称之为哈希法

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

242.有效的字母异位词

文章讲解：代码随想录 (programmercarl.com)

视频讲解：学透哈希表，数组使用有技巧！Leetcode：242.有效的字母异位词

题目链接：力扣题目链接

• 题目：给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
  • 先统计一个字符串中字符出现的情况，用哈希表（数组）记录
  • 再遍历第二个字符串

class Solution {
public:
    bool isAnagram(string s, string t) {
        //记录每个字符的哈希表
        int record[26] = {0};
        //遍历字符串s
        for (int i = 0; i < s.size(); i++) {
            //哈希映射：a-0 b-1...
            record[s[i] - 'a']++;
        }
        //遍历字符串t
        for (int i = 0; i < t.size(); i++) {
            record[t[i] - 'a']--;
        }
        //检查字符组成
        for (int i = 0; i < 26; i++) {
            if (record[i] != 0) {
                return false;
            }
        }
        return true;
    }
};

349.两个数组的交集

文章讲解：代码随想录 (programmercarl.com)

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

题目链接：349. 两个数组的交集 - 力扣（LeetCode）

• 题目：给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序
• 使用数组来做哈希的题目，是因为题目都限制了数值的大小

set

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        //使用set--去重
        unordered_set<int> result_set;
        //放入set中会自动去重
        unordered_set<int> nums_set(nums1.begin(), nums1.end());
        //遍历nums2并在nums_set中查找是否有相同元素
        for (int num : nums2) {
            if (nums_set.find(num) != nums_set.end()) {
                result_set.insert(num);
            }
        }
        return vector<int> (result_set.begin(), result_set.end());
    }
};

数组

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        int hash[1000] = {0};
        unordered_set<int> result_set;
        //遍历标记num1中有哪些元素
        for (int num : nums1) {
            hash[num] = 1;
        }
        //遍历nums2判断哪些元素和nums1中是相同的
        for (int num : nums2) {
            //相同则在hash中被标记
            if (hash[num] == 1) {
                result_set.insert(num);
            }
        }
        return vector<int> (result_set.begin(), result_set.end());
    }
};

202.快乐数

文章讲解：代码随想录 (programmercarl.com)

题目链接：202. 快乐数 - 力扣（LeetCode）

• 题目：编写一个算法来判断一个数 n 是不是快乐数。

  「快乐数」 定义为：

  对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
  然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
  如果这个过程 结果为 1，那么这个数就是快乐数。
  如果 n 是 快乐数 就返回 true ；不是，则返回 false。

  • 不断计算每个位置数字上的平方和，当和为1是返回true，当和出现重复时使命出现的无限循环，则返回false
  • 如何判断是否重复：快速找到集合中的元素----哈希表，对元素的范围是不明确的，所以不能使用数组，这里我们使用set，将每次计算出的平方和放入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;
            } else {
                if (set.find(sum) != set.end()) {
                    return false;
                } else {
                    set.insert(sum);
                    n = sum;
                }
            }
        }  
    }
};

1.两数之和

文章讲解：代码随想录 (programmercarl.com)

视频讲解：梦开始的地方，Leetcode：1.两数之和

题目链接：1. 两数之和 - 力扣（LeetCode）

• 题目：给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

  你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

  你可以按任意顺序返回答案。

  数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费

  set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用

  此时就要选择另一种数据结构：map ，map是一种key value的存储结构，可以用key保存数值，用value在保存数值所在的下标

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++) {
            auto iter = map.find(target - nums[i]);
            if (iter != map.end()) {
                return {iter->second, i};
            }
            map.insert(pair<int,int>(nums[i], i));
        }
        return {};
    }
};