算法LeetCode Day5 --哈希表

hash表也叫散列表，有很多种。

哈希表是根据关键码的值而直接进行访问的数据结构。

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

哈希表有如下三种数据结构。

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

 std::unordered_set底层实现为哈希表，std::set 和std::multiset 的底层实现是红黑树，红黑树是一种平衡二叉搜索树，所以key值是有序的，但key不可以修改，改动key值会导致整棵树的错乱，所以只能删除和增加。

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

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

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

242.有效的字母异位数

我是用自己写的这个代码，通过了

class Solution {
public:
    bool isAnagram(string s, string t) {
        if (s.length() != t.length()) return false;
        
        unordered_map<char, int> countMap;
        
        for (const auto &c : s) {
            countMap[c]++;
        }
        for (const auto &c : t) {
            countMap[c]--;
            if (countMap[c] < 0) {
                return false;
            }
        }   
        return true;
    }
};

代码随想录给的解答是用数组来搞的，其实都差不多。

349.两个数组的交集

因为它说输出的元素要是唯一的，所以应该利用set来进行去重，std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表， 使用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。

另外在unordered_set里面插入元素是insert，找元素是find。

代码如下:

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

另外因为这个函数开头定义的是vector<int>，所以最后输出的时候要对这个进行转换。

202.快乐数

这个的关键就是这个无限循环，我们当然不能让它无限循环下去不然就超过了时间限制了，一般无限循环的都会曾经的东西出现过，所以我们就用unordered_set来记录它的每次sum，若发现重复出现了，就返回false。

代码：

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

使用数组和set来做哈希法的局限。

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

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

std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。

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

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

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> hashmap;
        for(int i=0;i<nums.size();i++)
        {
         auto iter = hashmap.find(target - nums[i]);
            if(iter!=hashmap.end())
               return {iter->second,i};
            hashmap[nums[i]] = i;
        }
        return {};
    }
};

iter->second指向的是value值也就是下标。