代码随想录算法训练营第六天

一、哈希

1、为什么会想到用哈希表

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

2、哈希表什么时候用map？map中的key和value用来存什么的？

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

对于其他：

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

3、数组也是一个简单的哈希表：record[s[i]]++

4、哈希表什么时候使用set数组呢？

如果题目没有限制数值的大小，就无法使用数组来做哈希表了。

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

此时就要使用另一种结构体了，set ，关于set，C++ 给提供了如下三种可用的数据结构：

• std::set
• std::multiset
• std::unordered_set

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

5、用法：

set：

1) find

2) insert

3)erase(): 用于删除指定元素或范围内的元素。

4)clear(): 清空集合中的所有元素。

5)count(): 返回集合中指定元素的数量，由于 std::set 中元素唯一，所以结果要么是 0，要么是 1。 6)empty(): 检查集合是否为空，如果为空则返回 true，否则返回 false。

7)size(): 返回集合中元素的数量。

8)lower_bound() 和 upper_bound(): 分别返回第一个不小于给定值和第一个大于给定值的迭代器，用于范围查找。

二、题目

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] 也是可通过的

提示：

• 1 <= nums1.length, nums2.length <= 1000
• 0 <= nums1[i], nums2[i] <= 1000

题解：

 1、由于做了数组限制可以使用数组来作哈希

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        int result[1000]={0};
        vector<int>vec;
        for(int i=0;i<nums1.size();i++){
            result[nums1[i]]++;
        }
        for(int i=0;i<nums2.size();i++){
            if(result[nums2[i]]>0){
                vec.push_back(nums2[i]);
            }
        }
        std::sort(vec.begin(), vec.end()); // 先排序，确保相同元素相邻
        auto last = std::unique(vec.begin(), vec.end()); // 去重
        vec.erase(last, vec.end()); // 删除重复元素后的部分
        return vec;
    }
};

std::unique是STL中的一个函数，用于在容器中去除相邻的重复元素。当然，它并不会真正删除重复的元素，而是将它们移动到容器的末尾，并返回一个指向新的"逻辑尾部"的迭代器。如果你想要真正删除重复的元素，需要结合使用erase函数。

2、使用unordered_set

set可以自动去重！

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());
        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());
    }
};

nums_set.find(num) != nums_set.end()  ：检查 num 是否存在于名为 nums_set 的 std::set 容器中。std::set::find 函数会在集合中查找指定的元素，如果找到了，就返回指向该元素的迭代器；如果找不到，则返回集合的末尾迭代器 end()。

2、

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

提示：

• 1 <= n <= 231 - 1

题解：

n % 10 表示取整数 n 的个位数，即对 n 进行除以 10 的取余操作，得到的结果就是 n 的个位数。

n / 10 表示整数 n 除以 10 得到的商，即将 n 向下取整到十位数。

举个例子，假设 n 是 123：

• n % 10 就是 3，因为 123 除以 10 的余数是 3。
• n / 10 就是 12，因为 123 除以 10 得到的商是 12。

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=n;
        while(1){
            sum=getsum(sum);
            if(sum==1){
                return true;
            }
            if(set.find(sum)!=set.end()){
                return false;
            }
            set.insert(sum);
        }
    }
};

3、

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]

提示：

• 2 <= nums.length <= 104
• -109 <= nums[i] <= 109
• -109 <= target <= 109
• 只会存在一个有效答案

题解： 

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int>map;
        for(int i=0;i<nums.size();i++){
            auto it=map.find(target-nums[i]);
            if(it!=map.end()){
                return {it->second,i};
            }
            map.insert(pair<int, int>(nums[i], i));
        }
        return {};
    }
};

若是先将数组整个放入map中，map.find(target-nums[i])会有重复，所以将上一步放入查找下一个数在不在。

map.insert(pair<int, int>(nums[i], i));map需要插入两个元素，比如pair 对象，包含两个元素：nums[i] 和 i。