从零单排代码随想录 | Day5 哈希表 242、349、202、1-CSDN博客

本文链接：https://blog.csdn.net/m0_60313020/article/details/131407075

242.有效的字母异位词

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26]={0};
        for (int i=0; i < s.size(); i++){
            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){
                return false;
            }
        }
        return true;
    }
};

这里还是利用了字母和ASCII码的特性；
了解字符串数组；
字母相减就是其ASCII码的差值，同时而言是他们的位序之差。

349. 两个数组的交集

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

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

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

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

/ 在这边我的理解就是一组数组输入进去，提取出其中不重复的元素。
在这里插入图片描述
这里我关于std:unordered_set做了更进一步的调研和学习：

std::unordered_set 是 C++ STL 中的一个关联容器，它以哈希表的形式存储元素，并支持高效的插入、删除和查找操作。下面是一些常见的 std::unordered_set 成员函数：

insert: 往 unordered_set 中插入一个元素；
erase: 从 unordered_set 中删除一个元素；
find: 在 unordered_set 中查找一个元素，返回指向该元素的迭代器，如果未找到则返回一个指向 unordered_set 尾部之后位置的迭代器（即 unordered_set::end()）；
clear: 删除所有元素，使 unordered_set 变为空；
empty: 判断 unordered_set 是否为空；
size: 返回 unordered_set 中元素的数量。
此外，std::unordered_set 还有许多其他成员函数，如 emplace, emplace_hint, reserve, bucket_count, max_load_factor 等等。这些函数的具体含义可以参考 C++ STL 文档。

nums_set.end() 是 unordered_set 的成员函数，返回一个指向容器尾部后面位置的迭代器，表示一个不存在于unordered_set中的虚拟元素。具体来说，对于unordered_set而言，其内部实现是哈希表，nums_set.end() 返回一个迭代器，该迭代器指向哈希表的末端（即最后一个桶的下一个位置）。
在查找元素时，**如果某个元素不在 unordered_set 中，则 find() 函数会返回 nums_set.end() **这个迭代器，表示未找到该元素。因此，这段代码中的 if (nums_set.find(num) != nums_set.end()) 的含义是：查找 num 是否在 nums_set 中，如果不在则说明该元素不在 nums1 数组中出现过，如果存在则说明该元素也出现在了 nums1 数组中，可以将其插入到结果集合 result_set 中。

我这边自己的理解就是，在unordered_set中，num.end()就类似于一个空指针，如果没有搜索到，就返回到空指针，此时将这个Number塞到Result哈希表中。

for(int number:nums2)这个是针对数组遍历的意思，遍历nums中的每一个数赋予给number。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;
        unordered_set<int> nums_set(nums1.begin(),nums1.end());
        for (int number:nums2){
            if(nums_set.find(number)!=nums_set.end()){
                result_set.insert(number);
            }
        }
        return vector<int>(result_set.begin(),result_set.end());
    }
};

vector(result_set.begin(), result_set.end()); 这行代码创建了一个 vector 数组，并用数据库查询结果集中的所有元素来初始化它。
让我们逐个解释这行代码的不同部分：
vector：声明要创建的数组类型为 int 类型的 vector 数组。
(result_set.begin(), result_set.end())：使用 C++ STL 中的迭代器将 result_set 的开始和结束位置之间的元素添加到新的 vector 数组中。具体地说，result_set.begin() 返回第一个元素的迭代器，而 result_set.end() 返回最后一个元素后面的迭代器，因此这个表达式返回整个结果集中的所有元素。
综上所述，这行代码的作用是创建一个新的 vector 数组，并用数据库查询结果集的所有元素来初始化它。

202.快乐数

题目中说了会无限循环，那么也就是说求和的过程中，sum会重复出现，这对解题很重要！
需要使用到hash表来对无限循环中出现的重复数进行判断！

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 (n!=1){
            int i=GetSum(n);
           	n=i;
            if(Set.find(i)!=Set.end()) {
              return false;   
            }
                else{ 
                Set.insert(i);
                }
        }
        return true;
    }
};

这个是卡哥写的：

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

//这个while(1)的写法真的梦回单片机了，就是在一个无线循环分别对1和非1情况讨论；我的是得到1就跳出循环，不然就再浅浅循环一会。

//这边也摸到了循环的感觉，因为只要出现的重复数，就陷入了无限的莫比乌斯循环，此时就跳不出来了。必定没机会成为1了！

1.两数之和

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        for(int i=0; i<nums.size(); i++){
            vector<int>::iterator pos= find(nums.begin(),nums.end(),nums[i]);
            vector<int>::iterator pos2= find(pos+1,nums.end(),target-nums[i]);
            if(pos2!=nums.end()){
                int s = pos2-nums.begin();
                return{i,s};
            }
        }
        return{0,0};
    }
};

这个是和同学共同探索出的解法，其实和Hashmap还是有类似之处的，但主要还是利用了find函数，实际用起来可能也不太行；
对iterator迭代器也有了更深的认识，即一个类似于临时访问的地址，而不是一个具体的内存分配地址（&）。
但是这边也依然强调一点，就是find函数本身依然还是一个时间复杂度为O（n）的函数，所以整个还是类似于暴力解法，只不过用的函数略有不同，这需要谨慎。

也更理解了哈希表的妙用，反正只要是找某个数，就可以用哈希表；一个数就用set，两个数就用map。

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({nums[i], i}); 
        }
        return {};
    }
};