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

哈希表的理论基础

一般哈希表都是用来快速判断一个元素是否出现集合里。

当我们想使用哈希法来解决问题的时候，我们一般会选择如下三种数据结构。

• 数组
• set(集合）
• map(映射)

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

242.有效的字母异位词

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

-转自代码随想录

定义一个数组叫做record用来上记录字符串s里字符出现的次数。

需要把字符映射到数组也就是哈希表的索引下标上，因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。

再遍历 字符串s的时候，只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。 这样就将字符串s中字符出现的次数，统计出来了。

那看一下如何检查字符串t中是否出现了这些字符，同样在遍历字符串t的时候，对t中出现的字符映射哈希表索引上的数值再做-1的操作。

那么最后检查一下，record数组如果有的元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符，return false。

最后如果record数组所有元素都为零0，说明字符串s和t是字母异位词，return true。

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

1.bool用来定义string字符串

int record[26]={0} 来定义一个26位里面数字都是0的数组

2.其中record[s[i]-'a']++的意思为，s[i]里面每一个不同的字母的位置的ascii码减去a的ascii码对应的数字得出一个相对数字，即相对位置 ，对应了每一个数组里的元素。先在string s里面进行++ 的操作，再在string t里面进行--的操作。

3.这道题是用数组来解决的问题，因为需要的内存空间很小，且是连续的。

349. 两个数组的交集

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

但是要注意，使用数组来做哈希的题目，是因为题目都限制了数值的大小。

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

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

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

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

std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表， 使用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_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());
    }
};

1.其中nums1表示第一个数组，用来处理生成哈希表，nums2用来查找在已存在的哈希表中有没有这个数字，其中为了去重，result的哈希表用unorderedset_result来去重。

2.unordered_set<int> nums_set(nums1.begin(),nums1.end());

就是把nums1当中的全都放到nums_set当中，进行一个遍历

3. if(nums_set.find(num)!=nums_set.end()){

        result_set.insert(num);}

相当于c++的api。生成一个迭代器find，一直找到末尾，等于末尾的时候相当于没找到，这里不等于末尾说明找到了就是存在在set当中

4.for(int num:num2)是范围for循环，代表含义是从nums2的int型数组中依次将值赋值给num，将num带入for语句代码块中执行。

int num;
for(int i=0;i<nums.length;i++)
{
num=nums2[i];
}

5.最终把set转变为vector,返回到一个数组的形式。

vector<int>(result_set.begin(), result_set.end())

202. 快乐数

202. 快乐数 - 力扣（LeetCode）

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

1.int getSum(int n)是一种getSum函数的定义方法

1. 两数之和 

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

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

本题呢，我就需要一个集合来存放我们遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，也就是 是否出现在这个集合。

那么我们就应该想到使用哈希法了。

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

再来看一下使用数组和set来做哈希法的局限。

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

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

c++中map的三种类型：

接下来需要明确两点：

• map用来做什么
• map中key和value分别表示什么

map目的用来存放我们访问过的元素，因为遍历数组的时候，需要记录我们之前遍历过哪些元素和对应的下表，这样才能找到与当前元素相匹配的（也就是相加等于target）

接下来是map中key和value分别表示什么。

这道题 我们需要 给出一个元素，判断这个元素是否出现过，如果出现过，返回这个元素的下标。

那么判断元素是否出现，这个元素就要作为key，所以数组中的元素作为key，有key对应的就是value，value用来存下标。

所以 map中的存储结构为 {key：数据元素，value：数组元素对应的下表}。

在遍历数组的时候，只需要向map去查询是否有和目前遍历元素比配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为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(pair<int, int>(nums[i], i)); 
        }
        return {};
    }
};

 1. iter->second 取迭代器的成员值,second代表value，first代表key，map中存放一对一对的元素，迭代器是一个指针，故使用箭头。vector中的beign()就是一个迭代器

while(cur){
temp=cur->next;
cur->next

2.这个cur->next这个就是指针而已，节点的指针,next是节点中的成员。cur是一个变量，而next是节点的成员，cur是遍历链表时，用的变量，跟迭代器跟相似。因为这个链表不是stl的一部分，所以没有显式的迭代器。

3.auto的原理就是根据后面的值，来自己推测前面的类型是什么。

auto的作用就是为了简化变量初始化，如果这个变量有一个很长很长的初始化类型，就可以用auto代替。