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

代码随想录算法训练营第六天|哈希表理论基础、242.有效的字母异位词、349.两个数组的交集、202快乐数、1. 两数之和

哈希表理论基础

哈希表：可以看成是一个数组来存储数据，每个数组项通过哈希函数计算出一个哈希值，这个哈希值用于数组的索引。理想情况下，每个键都映射到一个唯一的数组索引上。

哈希函数：是将输入转换成一个整数的函数，这个整数可以用作数组的索引。一个好的哈希函数应该满足以下条件：

• 高效计算：哈希函数应该容易计算，不应该成为整个哈希表操作的瓶颈。
• 均匀分布：哈希函数应该尽可能均匀地将输入分布到哈希表的各个位置，减少冲突。

哈希碰撞：哈希碰撞发生在两个不同的输入通过哈希函数产生相同的输出索引时。解决哈希碰撞的常见方法包括：

• 拉链法：每个数组索引处存储一个链表，所有映射到该索引的元素都存储在这个链表中。
  

• 线性探测法：当一个索引已经被占用时，算法寻找下一个空闲的索引位置。
  

• 数组：以连续的内存空间顺序存储数据元素，可以通过索引快速访问任何位置的元素。但数组的大小是固定的，且数据类型必须统一。

• 集合：

集合	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::set	红黑树	有序	否	否	O(log n)	O(log n)
std::multiset	红黑树	有序	是	否	O(logn)	O(logn)
std::unordered_set	哈希表	无序	否	否	O(1)	O(1)

• 映射

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::map	红黑树	key有序	key不可重复	key不可修改	O(logn)	O(logn)
std::multimap	红黑树	key有序	key可重复	key不可修改	O(log n)	O(log n)
std::unordered_map	哈希表	key无序	key不可重复	key不可修改	O(1)	O(1)

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

242. 有效的字母异位词

题目

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

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

示例 1:

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

示例 2:

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

思路

这道题可以利用哈希表的方法解决，因为共有26个字母，可以定义一个长度为26的数组，然后通过遍历的方式记录s中每个字母出现的次数，再与t中每个字母出现的次数进行比较即可。

具体代码如下：

class Solution {
public:
    bool isAnagram(string s, string t) {
        // 记录数组
        int record[26] = {0};
        // 遍历s
        // 记录每个字母出现次数
        for(int i = 0; i < size(s) ; i++){
            record[s[i]-'a']++;
        }
        // 遍历t
        for(int i = 0; i < size(t) ; i++){
            record[t[i]-'a']--;
        }
        // 检查是否为0
        for(int i = 0; i < size(record); i++){
            if(record[i]!=0){
                return false;
            }
        }
        return true;
    }
};

• 时间复杂度: O(n)
• 空间复杂度: O(1)

349. 两个数组的交集

题目

给定两个数组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] 也是可通过的

思路

因为不需要对数据进行排序，而且还不让数据重复，所以选择unordered_set

具体思路如下：

先将nums1转换为unordered_set，目的是让其去重，再将nums2中的每个元素与去重后的set进行比较，如果存在相同元素，则记录结果。

具体代码如下：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        // 定义结果set
        unordered_set<int> result_set;
        // 定义去重后的nums
        unordered_set<int> nums_set(nums1.begin(), nums1.end());
        // 遍历nums2中的元素
        for(int num : nums2){
            // 若发现存在于nums_set中 则添加到结果set中
            if(nums_set.find(num)!=nums_set.end()){
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(),result_set.end());
    }
};

• 时间复杂度: O(n + m) m 是最后要把 set转成vector
• 空间复杂度: O(n)

第202题. 快乐数

编写一个算法来判断一个数 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是否重复来判断是否是快乐数

还是使用unordered_set

class Solution {
public:
    // 求和
    int getSum(int n){
        int sum = 0;
        while(n){
            sum = sum + (n%10)*(n%10);
            n = n/10;
        }
        return sum;
    }
    bool isHappy(int n) {
        unordered_set<int> set;
        while(1){
            // 求和
            int sum = getSum(n);
            // =1 为快乐数
            if(sum == 1){
                return true;
            }
            // 如果出现过，说明开始循环
            if(set.find(sum)!=set.end()){
                return false;
            }else{
                set.insert(sum);
            }
            n=sum;
        }
    }
};

• 时间复杂度: O(logn)
• 空间复杂度: O(logn)

1. 两数之和

题目

给定一个整数数组 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]

思路

具体思路如下：

具体代码如下：

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

• 时间复杂度: O(n)
• 空间复杂度: O(n)

📎 参考文章

代码随想录哈希表理论基础

代码随想录0242.有效的字母异位词

代码随想录0349.两个数组的交集

代码随想录0202.快乐数

代码随想录0001.两数之和