一刷代码随想录day5（● 哈希表理论基础 ● 242.有效的字母异位词 ● 349. 两个数组的交集 ● 202. 快乐数● 1. 两数之和 ）

哈希表理论基础：

定义：

哈希表是根据关键码的值而直接进行访问的数据结构，例如数组的下标索引就是关键码的一种。

数据通过哈希函数（Code）映射到关键码，将数据存进哈希表中。

哈希表一般来快速判断一个元素是否出现集合里，时间复杂度为O(1)。

哈希函数（HashFunction）：

一般通过编码，将不同的数据转化会关键码（或者索引），称为hashcode，若hashcode得出的索引值大于tablesize，将其索引进行取模，就可以放入数组中，但若想要放入的数据大于tablesize，不管如何均匀都会出现多个数据对应一个索引，此时就要引入hash碰撞。

哈希碰撞：

即两个数据映射到了同一个索引（如下图）

解决方法：

拉链法：

在同一索引处，设置链表存储数据，通过链表访问数据（如下图）

线性探测法

首先要求数据量小于tablesize，在冲突的位置放下元素后，将其余元素向下遍历找到空位并存入。

哈希法的实现一般有

• 数组
• set （集合）

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

• map(映射)

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

当我们要使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset。

那么再来看一下map ，在map 是一个key value 的数据结构，map中，对key是有限制，对value没有限制的，因为key的存储方式使用红黑树实现的。

242.有效的字母异位词

题意：

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

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

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

解决方案：

暴力解法：双重循环，判断字母是否都出现且个数相同，且同一位置上字母是否有不同

哈希解法：建立一个长度为26的数组，将首个字符串字母根据ASCII码中的相对位置记录在数组中，出现一次数组数值+1，遍历完第一个字符串后，再遍历第二个字符串，出现一次相同字母，在数组对应位置-1。

代码：

class Solution {
public:
    bool isAnagram(string s, string t) {
        int judge[26]={0};
        for(int i=0;i<s.length();i++){
        judge[s[i]-'a']++;
        }
        for(int j=0;j<t.length();j++){
        judge[t[j]-'a']--;
        }
        for(int k =0 ;k<26;k++){
            if(judge[k]!=0){
                return false;
            }
        }
        return true;
    }
};

349. 两个数组的交集

题意：

给定两个数组，编写一个函数来计算它们的交集。

解决方法：

1、利用set解决，将num1的数据存入set，set自动去重后，之后遍历num2，找到相同的数组存入结果的set内，再将set强转为vector即可（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());
    }
};

2、利用数组哈希解决，直接用数值进行映射，出现了就赋值为1（此时进行了去重）,再判断用nums2的值访问的数组有没有被赋值，有的话将其存入结果set即可

代码如下:

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        int hash[1005] = {0}; // 默认数值为0
        for (int num : nums1) { // nums1中出现的字母在hash数组中做记录
            hash[num] = 1;
        }
        for (int num : nums2) { // nums2中出现话，result记录
            if (hash[num] == 1) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

快乐数

题意：

「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为  1，那么这个数就是快乐数。

如果 n 是快乐数就返回 True ；不是，则返回 False 。

解法：

用set去保存输入数字处理后的sum，每得到一个sum，若为1，证明为快乐数，反之则与原先set的元素进行比较，若不存在，存入，若已存在，说明进入死循环，证明不是快乐数。

代码：

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. 两数之和

题意：

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

解法：

本题主要的解题思路就是在遍历数组中，寻找是否之前遇到过满足条件的值，并返回现在的下标与之前值的下标，因此使用map，因为map可以保存两个值，key与value，此时将数组内的数值作为key，下标作为value，因为查找时使用map查key是最快的，本题中要查找的值应该放在key处方便查找，如果找到满足题意的值就返回下标，不满足题意就将其存入，进行下一次迭代。

代码如下

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、为什么使用map 2、map存的值是什么 3、map的key和value分别存的什么