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

哈希表理论基础（转载自代码随想录）

常见的三种哈希结构

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

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

这里数组就没啥可说的了，我们来看一下set。

在C++中，set 和 map 分别提供以下三种数据结构，其底层实现以及优劣如下表所示：

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

std::unordered_set底层实现为哈希表，std::set 和std::multiset 的底层实现是红黑树，红黑树是一种平衡二叉搜索树，所以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也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）。

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

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

其他语言例如：java里的HashMap ，TreeMap 都是一样的原理。可以灵活贯通。

虽然std::set、std::multiset 的底层实现是红黑树，不是哈希表，std::set、std::multiset 使用红黑树来索引和存储，不过给我们的使用方式，还是哈希法的使用方式，即key和value。所以使用这些数据结构来解决映射问题的方法，我们依然称之为哈希法。 map也是一样的道理。

这里在说一下，一些C++的经典书籍上 例如STL源码剖析，说到了hash_set hash_map，这个与unordered_set，unordered_map又有什么关系呢？

实际上功能都是一样一样的， 但是unordered_set在C++11的时候被引入标准库了，而hash_set并没有，所以建议还是使用unordered_set比较好，这就好比一个是官方认证的，hash_set，hash_map 是C++11标准之前民间高手自发造的轮子。

242.有效的字母异位词

方法一（unordered_Map）

class Solution {
public:
    bool isAnagram(string s, string t) {
        if(s.length()!=t.length()) return false;  //string数目不一致，退出

        unordered_map charCount;

        for(char c:s)  charCount[c]++;
        for (char c : t)
        {
            if (charCount.find(c) == charCount.end() || charCount[c] <= 0) {   //迭代器搜索到末尾，或者发现这个string还需要--，提前退出
            return false;
        }
         charCount[c]--;
        }

        for (auto it = charCount.begin() ; it != charCount.end(); it++) { //迭代器，确保所有Map没有重复值
            if (it->second != 0) {
                return false;
            }
        }
    return true;   
    }
};

方法二（数组）

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = {0};
        for (int i = 0; i < s.size(); i++) {
            // s[i] -'a'自动转换为数据
            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;
    }
};

349.两个数组的交集

方法一（unordered_Set）

class Solution {
public:
    vector intersection(vector& nums1, vector& nums2) {
        unordered_set Result;
        unordered_set Verifynums(nums1.begin(),nums1.end());

        for(auto num:nums2)
        {
            if(Verifynums.find(num) != Verifynums.end())
            {
                Result.insert(num);
            }
        }
        return vector(Result.begin(),Result.end());
    }
};

方法二（数组）

class Solution {
public:
    vector intersection(vector& nums1, vector& nums2) {
        unordered_set result_Set;
        int hash[1005] ={0};
        for(int num:nums1)
        {
            hash[num] = 1;
        }
        for(int num:nums2)
        {
            if(hash[num] ==1) result_Set.insert(num);
        }
        return vector(result_Set.begin(),result_Set.end());
    }
};

202.快乐数

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

class Solution {
public:
    vector twoSum(vector& nums, int target) {
        std::unordered_map  resultMap;
        for(int i = 0; i < nums.size(); i++) {
            // 遍历当前元素，并在map中寻找是否有匹配的key
            auto iter = resultMap.find(target - nums[i]); 
            if(iter != resultMap.end()) {
                return {iter->second, i};
            }
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            resultMap.insert(pair(nums[i], i)); 
        }
        return {};
    }
};