代码随想录算法训练营第六天| LeetCode| C++| 242.有效的字母异位词、349. 两个数组的交集、202. 快乐数、1. 两数之和

哈希表

定义： 哈希表（hash table / 散列表）是根据关键码的值而直接进行访问的数据结构。
其实直白来讲其实数组就是一张哈希表。哈希表中关键码就是数组的索引下标，然后通过下标直接访问数组中的元素。

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

哈希函数
哈希碰撞（拉链法、线性探测法）

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

• 数组
• set （集合）
• map(映射)
  在C++中，set 和 map 分别提供以下三种数据结构，其底层实现以及优劣如下表所示：

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

红黑树是一种平衡二叉搜索树，所以key值是有序的，但key不可以修改，改动key值会导致整棵树的错乱，所以只能删除和增加。

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
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)

std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。同理，std::map 和std::multimap 的key也是有序的 （这个问题也经常作为面试题，考察对语言容器底层的理解）。

242.有效的字母异位词

思路：
1、26个字母，数值和范围可控，用数组即可
2、第一次for循环统计字母出现频率
3、第二次for循环消去对应字母
4、判断数组里的值是否为0

正确代码如下：

class Solution {
public:
    bool isAnagram(string s, string t) {
        /*
            1、26个字母，数值和范围可控，用数组即可
            2、第一次for循环统计字母出现频率
            3、第二次for循环消去对应字母
            4、判断数组里的值是否为0
        */
        int hash[26] = {0};

        for(int i = 0; i < s.size(); i++){
            hash[s[i] - 'a']++;
        }

        for(int i = 0; i < t.size(); i++){
            hash[t[i] - 'a']--;
        }

        for(int i = 0; i < 26; i++){
            if(hash[i] != 0) return false;
        }
        return true;
    }
};

349. 两个数组的交集

思路：
1、采用unordered_set其映射和取值的效率最高，且自动去重
2、数组nums1用哈希表来存其所有的数值
3、用数组nums2去遍历查询元素是否出现过，出现过则放进result集合

注意：
1、set容器的查找函数原型find(key); //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
2、set容器的插入函数原型insert(elem); //在容器中插入元素。
3、最终要返回数组，将set容器转为vector容器

正确代码如下：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        /*
            1、采用unordered_set自动去重，且其映射和取值的效率最高
            2、数组nums1用哈希表来存其所有的数值，
            3、用数组nums2去遍历查询元素是否出现过，出现过则放进result集合
        */
        unordered_set<int> result_set;// 存放结果，之所以用set是为了给结果集去重
        unordered_set<int> nums_set(nums1.begin(), nums1.end());
        for(int i = 0; i < nums2.size(); i++){
            // 发现nums2的元素 在nums_set里又出现过
            if(nums_set.find(nums2[i]) != nums_set.end()){
                result_set.insert(nums2[i]);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

采用数组也可，因为限定了数组的大小和容量
1 <= nums1.length, nums2.length <= 1000

0 <= nums1[i], nums2[i] <= 1000

正确代码如下：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;
        int hash[1001] = {0};

        for(int i = 0; i < nums1.size(); i++){
            hash[nums1[i]]++;
        }
        
        for(int i = 0; i < nums2.size(); i++){
            if(hash[nums2[i]] >= 1 ){
                result_set.insert(nums2[i]);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

202. 快乐数

思路：
1、平方和可能会无限循环（while(1))，则可以判断一个元素是否出现在集合里（哈希法）
2、判断sum是否重复出现就可以使用unordered_set
3、取数值各个位上的单数之和getSum()

完整代码如下：

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; //一轮循环后sum值替代原来的n值，继续循环
        }
    }
};

1. 两数之和

解法一：哈希法

重点：
1、为什么想到使用哈希法（要查找的是元素是否出现过
2、为什么要用map（为什么用unordered_map，因为要知道元素是否出现过 以及 元素的下标 （value 和 key）用map
3、map是用来做什么的（用来存放遍历过的元素
4、key是存放什么的，value是存放什么的（key存放元素数值，value存放元素下标

注意：
1、map的创建方式为unordered_map<int, int> map;
2、auto：C++11引入了auto类型说明符，用它来让编译器替我们去分析表达式所属的类型。(此处find()函数是返回一个迭代器，不用aotu则写作unordered_map<int, int>::iterator iter = map.find(target - nums[i]);
3、map类型的key和value返回为->first和->second
4、pair是对组，成对出现的数据，利用对组可以返回两个数据

完整代码如下：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        /*
            1、为什么想到使用哈希法
            2、为什么要用map（为什么用unordered_map
            3、map是用来做什么的（用来存放遍历过的元素
            4、key是存放什么的，value是存放什么的
        */
        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 {};
    }
};

解法二：暴力解法，双层for循环
完整代码如下：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        /*
            1、暴力解法，双层for循环
            2、一层for指向一个值，另一层for遍历
        */
        vector<int> result;
        for(int i = 0; i < nums.size(); i++){
            for(int j = i + 1; j < nums.size(); j++){
                if(nums[i] + nums[j] == target){
                    result.push_back(i);
                    result.push_back(j);
                }
            }
        }
        return result;
    }
};