Day5 哈希表01

Day5 哈希表01

一、哈希表基础

1、哈希表（Hash Table）

哈希表也叫做散列表。哈希表是根据关键码的值（Key Value）而直接进行访问的数据结构。

与普通的列表不同的地方在于，普通列表仅能通过下标来获取目标位置的值，而哈希表可以根据给定的 key 计算得到目标位置的值。

在列表查找中，使用最广泛的二分查找算法，复杂度为 O(log2n)，但其始终只能用于有序列表。普通无序列表只能采用遍历查找，复杂度为 O(n)。

而拥有较为理想的哈希函数实现的哈希表，对其任意元素的查找速度始终为常数级，即 O(1)。

为什么哈希表是如何通过 key 来计算到目标位置的值的呢？这个计算的的映射就是由哈希函数来做到的。

2、哈希函数

哈希函数，是一种从任何一种数据中创建小的数字“指纹”的方法。散列函数把消息或数据压缩成摘要，使得数据量变小，将数据的格式固定下来。该函数将数据打乱混合，重新创建一个叫做散列值（hash values，hash codes，hash sums，或hashes）的指纹。散列值通常用一个短的随机字母和数字组成的字符串来代表。

在一个典型的哈希表实现中，哈希表函数的操作是将 key 值直接对其取模，所得的值为数组下标。
当我们的 Value 的数量大于这个表的大小的时候，总会有碰撞现象出现。

3、哈希碰撞

• 拉链法
  • 拉链法就是要选择适当的哈希表的大小，这样既不会因为数组空值而浪费大量内存，也不会因为链表太长而在查找上浪费太多时间。
    
• 线性探测法
  • 一定要保证tableSize大于dataSize。 我们需要依靠哈希表中的空位来解决碰撞问题。
    

二、有效的字母异位词(数组)

242. 有效的字母异位词 - 力扣（LeetCode）

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

**注意：**若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

• Tips：遇到一个哈希表类似操作方式的，可以尝试思考一下能不能用数组。
• 定义一个长度为 26 的数组，一个数组存储第一个字符串的每一个字母的出现次数。
• 在遍历第二个字符串的时候，每次遇到一个字母就将他的次数 -1 ，如果最终这个数组是一个充满了0 的数组，就证明这两个字符串出现的字母次数相同。
• 对于s[i] - 'a'，意思是如果数组里面的字母存在，则在对应的数组里面+1或-1；

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = {0};
        for (int i = 0; i < s.size(); i++) {
            // 并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
            record[s[i] - 'a']++;
        }
        for (int i = 0; i < t.size(); i++) {
            record[t[i] - 'a']--;
        }
        for (int i = 0; i < 26; i++) {
            if (record[i] != 0) {
                // record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return false;
            }
        }
        // record数组所有元素都为零0，说明字符串s和t是字母异位词
        return true;
    }
};

三、两个数组的交集(set)

349. 两个数组的交集 - 力扣（LeetCode）

给定两个数组 nums1 和 nums2 ，返回它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的

• 这道题要求返回的是两个数组的交集，并且这个交集是做了去重操作的。
• num1 转换为哈希表，遍历 num2 去哈希表里面查，有没有相同的值。
• 无序集合（unordered_set）：C++中的std::unordered_set是一个哈希表实现的集合，它可以用来存储唯一的元素，而且对于查找操作具有很高的效率；即可以进行去重操作。

class Solution {
public:
    std::vector<int> intersection(std::vector<int>& nums1, std::vector<int>& nums2) {
        // 创建两个无序集合set1和set2，并将nums1和nums2中的元素分别插入集合中
        std::unordered_set<int> set1(nums1.begin(), nums1.end());
        std::unordered_set<int> set2(nums2.begin(), nums2.end());
        
        // 创建一个用于存储交集元素的向量result
        std::vector<int> result;

        // 遍历set1中的每一个元素
        for (int num : set1) {
            // 检查set2中是否包含当前元素
            if (set2.count(num)) {
                // 如果包含，则将该元素添加到result中
                result.push_back(num);
            }
        }

        // 返回包含交集元素的向量
        return result;
    }
};

四、快乐数(set)

202. 快乐数 - 力扣（LeetCode）

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

「快乐数」 定义为：

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

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

示例 1：

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

示例 2：

输入：n = 2
输出：false

题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现，这对解题很重要！

**当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。**所以这道题目使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false， 否则一直找到sum为1为止。判断sum是否重复出现就可以使用unordered_set。

• 创建一个集合（HashSet）用于记录已经出现过的数，以便在计算过程中检查是否陷入循环。
• 对于给定的数 n，我们开始一个循环，直到满足以下条件之一：
  • n 变为了1，这时我们就可以确定它是一个快乐数。
  • n 已经在集合中出现过，说明我们陷入了无限循环，这时就可以确定它不是一个快乐数。
• 在循环中，我们将当前的 n 加入到集合中，然后通过计算每一位数字的平方和得到下一个数。
• 在计算下一个数时，我们可以将 n 的每一位数字取出，计算它们的平方和，得到新的数。
• 不断重复上述过程，直到满足循环结束的条件。
• 最后，如果 n 最终变为1，那么它是一个快乐数；否则，不是快乐数。

class Solution {
public:
    bool isHappy(int n) {
        // 创建一个无序集合 seen，用于记录已经出现过的数
        std::unordered_set<int> seen;

        // 循环条件：n 不等于 1 且 n 没有出现在 seen 中
        while (n != 1 && !seen.count(n)) {
            // 将当前的 n 加入到 seen 中
            seen.insert(n);

            // 计算下一个数
            n = getNext(n);
        }

        // 如果 n 最终等于 1，说明是快乐数；否则，不是快乐数
        return n == 1;
    }

    // 获取下一个数的函数
    int getNext(int n) {
        int totalSum = 0;

        // 将 n 的每一位数字的平方相加
        while (n > 0) {
            int digit = n % 10; // 取出当前位的数字
            totalSum += digit * digit; // 将当前位数字的平方加到总和中
            n /= 10; // 去掉 n 的最后一位数字
        }

        return totalSum; // 返回计算的总和作为下一个数
    }
};

五、两数之和(map)

1. 两数之和 - 力扣（LeetCode）

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

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

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

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

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

• 我们不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。

• map是一种key-value的存储结构，可以用key保存数值，用value再保存数值所在的下标。

  • map目的用来存放我们访问过的元素，因为遍历数组的时候，需要记录我们之前遍历过哪些元素和对应的下标，这样才能找到与当前元素相匹配的（也就是相加等于target）
  • std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。
    
    

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map<int,int> map;
        // 遍历当前元素，并在map中寻找是否有匹配的key
        for(int i = 0; i < nums.size(); i++){
            int s = target - nums[i];
            auto  iter = map.find(s);
            //如果找到了（这是c++里面的一种写法）
            if(iter != map.end()){
                return {iter->second, i};
            }
            
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int, int>(nums[i], i));
        }
        return {};
    }
};

六、总结

不太了解哈希表，中间两个题目其实还不太理解，先放一下吧。