算法题-哈希表

1.哈希表理论基础

1.1什么是哈希表

哈希表（hash table）是根据关键码的值而直接进行访问的数据结构。
哈希表中关键码就是数组的索引下标，然后通过下标直接访问数组中的元素。

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

1.2 哈希函数

哈希函数，把学生的姓名直接映射为哈希表的索引，然后就可以通过查询索引下标快速知道这位同学是否在这所学校里。
哈希函数如下所示：通过hashcode把名字转化为数值，一般hashcode是通过特定编码方式，可以将其他数据格式转化为不同的数值，这样就把学生名字映射微哈希表上的索引数字。

1.3哈希碰撞

小李和小王都映射到了索引下标 1 的位置，这一现象叫做哈希碰撞。

一般哈希碰撞有两种解决方法。拉链法和线性探测法

1.3.1拉链法

刚刚小李和小王在索引1的位置发生了冲突，发生冲突的元素都被存储在链表中。 这样我们就可以通过索引找到小李和小王了。

1.3.2线性探测法

使用线性探测法，一定要保证tableSize大于dataSize。 我们需要依靠哈希表中的空位来解决碰撞问题。
例如冲突的位置，放了小李，那么就向下找一个空位放置小王的信息。所以要求tableSize一定要大于dataSize ，要不然哈希表上就没有空置的位置来存放 冲突的数据了。如图所示：

1.4常用的三种哈希结构

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

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

1.4.1集合（set）和映射（map）

在c++中，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的存储方式使用红黑树实现的。
其他语言例如：java里的HashMap ，TreeMap 都是一样的原理。可以灵活贯通。
虽然std::set和std::multiset 的底层实现基于红黑树而非哈希表，它们通过红黑树来索引和存储数据。不过给我们的使用方式，还是哈希法的使用方式，即依靠键（key）来访问值（value）。所以使用这些数据结构来解决映射问题的方法，我们依然称之为哈希法。std::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标准之前民间高手自发造的轮子。

1.5set常用函数

函数	说明	用法示例
insert	插入元素	s.insert(value);
erase	删除元素	s.erase(value); 或 s.erase(iterator);
find	查找元素	auto it = s.find(value);
count	统计元素出现次数（对于 set，要么是0要么是1）	size_t count = s.count(value);
size	返回集合中的元素数量	size_t size = s.size();
empty	检查集合是否为空	bool isEmpty = s.empty();
clear	清空集合	s.clear();
begin	返回指向集合首元素的迭代器	auto it = s.begin();
end	返回指向集合尾后元素的迭代器	auto it = s.end();
rbegin	返回指向集合尾元素的逆向迭代器	auto it = s.rbegin();
rend	返回指向集合首前元素的逆向迭代器	auto it = s.rend();
lower_bound	返回指向第一个不小于给定值的元素的迭代器	auto it = s.lower_bound(value);
upper_bound	返回指向第一个大于给定值的元素的迭代器	auto it = s.upper_bound(value);
equal_range	返回一个范围，其中包含与给定值相等的所有元素	auto range = s.equal_range(value);

map常用函数

函数	说明	用法示例
insert	插入键值对	m.insert({key, value}); 或 m[key] = value;
erase	删除键值对	m.erase(key); 或 m.erase(iterator);
find	查找键	auto it = m.find(key);
count	统计键出现次数（对于 map，要么是0要么是1）	size_t count = m.count(key);
size	返回映射中的键值对数量	size_t size = m.size();
empty	检查映射是否为空	bool isEmpty = m.empty();
clear	清空映射	m.clear();
begin	返回指向映射首键值对的迭代器	auto it = m.begin();
end	返回指向映射尾后键值对的迭代器	auto it = m.end();
rbegin	返回指向映射尾键值对的逆向迭代器	auto it = m.rbegin();
rend	返回指向映射首前键值对的逆向迭代器	auto it = m.rend();
lower_bound	返回指向第一个不小于给定键的键值对的迭代器	auto it = m.lower_bound(key);
upper_bound	返回指向第一个大于给定键的键值对的迭代器	auto it = m.upper_bound(key);
equal_range	返回一个范围，其中包含与给定键相等的所有键值对	auto range = m.equal_range(key);
at	返回指定键的值（带边界检查）	value = m.at(key);
operator[]	返回指定键的值（如果键不存在则创建）	value = m[key];

2.相关算法题

2.1有效的字母异位词

题目

class Solution {
public:
    bool isAnagram(string s, string t) 
    {
        if(s.size() != t.size())
        {
            return false;
        }
        unordered_map<char, int> s_map;
        for(int i = 0; i < s.size(); i++)
        {
            s_map[s[i]]++;
            s_map[t[i]]--;
        }
        for(auto it : s_map)
        {
            if (it.second != 0)
            {
                return false;
            }    
        }
        return true;
    }
};

2.2两个数组的交集

题目

class Solution 
{
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) 
    {
        
        unordered_set<int> st(nums1.begin(), nums1.end());
        unordered_set<int> res_st;
        for (auto num2 : nums2)
        {
            if(st.find(num2) != st.end())
            {
                res_st.insert(num2);
            }
        }

        return vector<int> (res_st.begin(), res_st.end());;
    }
};

注意：将数组a转换成对应无序集合，只需要unordered_set<int> st(a.begin(), a.end()),不需要再遍历放入。

2.3两个数组的交集II

题目

class Solution 
{
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) 
    {
        vector<int> res;
        unordered_map<int, int> mp;
        for(int i = 0; i < nums1.size(); i++)
        {
            mp[nums1[i]]++;
        }
        for(int i = 0; i < nums2.size(); i++)
        {
            if (mp.find(nums2[i]) != mp.end() && mp[nums2[i]] > 0)
            {
                res.push_back(nums2[i]);
                mp[nums2[i]]--;
            }
        }
        return res;
    }
};

2.4快乐数

题目

class Solution {
private:    
    int decompose(int n)
    {
        int sum = 0;
        while(n > 0)
        {
            int n1 = n % 10;
            sum += n1 * n1;
            n = n / 10;
        }
        return sum;

    }
public:
    bool isHappy(int n) 
    {
        int num = n;
        unordered_set<int> st;

        while (1)
        {
            int res = decompose(num);
            if (res == 1)
            {
                return true;
            }
            else if  (st.find(res) != st.end())
            {
                return false;
            }
            else
            {
                st.insert(res);
            }
            num = res;       
        }
    }
};

2.5两数之和

题目

class Solution 
{
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        unordered_map<int, int> mp;
        mp[nums[0]] = 0;

        for(int i = 1; i < nums.size(); i++)
        {
            if (mp.find(target - nums[i]) != mp.end())
            {
                return {mp[target - nums[i]], i};
            }
            else
            {
                mp[nums[i]] = i;
            }
        }
        return {};
    }
};

2.6四数相加II

题目

class Solution 
{
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) 
    {
        unordered_map<int, int> mp;
 
        for(auto i : nums1)
        {
            for(auto j : nums2)
            {
                mp[i + j]++;
            }
        }

        int count  = 0;
        for(auto i : nums3)
        {
            for(auto j : nums4)
            {
                int target = -(i + j);
                if (mp.find(target) != mp.end())
                {
                    count += mp[target];
                }
            }

        }
        return count;
    }
};

2.7赎金信

题目

class Solution 
{
public:
    bool canConstruct(string ransomNote, string magazine) 
    {
        unordered_map<char, int> mp;
        for(char ch : magazine)
        {
            mp[ch]++;
        }
        for(char ch : ransomNote)
        {
            if (mp.find(ch) == mp.end() || mp[ch] <= 0)
            {
                return false;
            }
            else 
            {
                mp[ch]--;
            }
        }
        return true;
    }
};

2.8三数之和（*）

题目

解法一

#include <iostream>
#include <vector>
#include <unordered_map>
#include <set>
#include <algorithm>
using namespace std;
//set+双指针
class Solution 
{
public:
    vector<vector<int>> threeSum(vector<int>& nums) 
    {
        set<vector<int>> ret;//为了去重
        sort(nums.begin(), nums.end());
        int len = nums.size();
        for(int i = 0; i <len ;i++)
        {
            if(i && nums[i] == nums[i - 1]) //防止第一个数重复计算
            {
                continue;
            }
            //双指针遍历两数之和
            int target = -nums[i];
            int left = i + 1;
            int right = len - 1;
            while(left < right)
            {
                if(nums[left] + nums[right] > target)
                {
                    right--;
                }
                else if(nums[left] + nums[right] < target)
                {
                    left++;
                }
                else
                {
                    ret.insert({nums[i], nums[left], nums[right]});
                    left++;
                    right--;
                }
            }
            
        } 
        vector<vector<int>> ans(ret.begin(), ret.end());     
        return ans;
    }

};

注意：用set<vector<int> 去重

解法二

//排序+双指针+去重
class Solution
{
    public:
        vector<vector<int>> threeSum(vector<int>& nums) 
        {
            vector<vector<int> > res;
            sort(nums.begin(), nums.end());
            for (int i = 0; i < nums.size() - 2; i++)
            {
                if (nums[i] > 0)
                {
                    return res;
                }
                //对a去重
                if(i > 0 && nums[i] == nums[i - 1]) continue;

                //双指针
                int left = i + 1;
                int right = nums.size() - 1;
                while (left < right)
                {
                    if (nums[i] + nums[right] + nums[left] < 0) left++;
                    else if (nums[i] + nums[right] + nums[left] > 0) right--;
                    else
                    {
                        res.push_back({nums[i], nums[left], nums[right]});
                        //发现三元组后去重
                        while (right > left && nums[left] == nums[left + 1]) left++;
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        //找到答案时，同时收缩
                        right--;
                        left++;
                    }
                }               
            }
            return res;           
        }        
};

2.9四数之和

题目

class Solution 
{
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) 
    {
        set<vector<int>> ret; // 用于去重
        sort(nums.begin(), nums.end());
        int len = nums.size();
        
        for(int i = 0; i < len; i++)
        {
            if(i > 0 && nums[i] == nums[i - 1]) // 防止第一个数重复计算
            {
                continue;
            }
            for(int j = i + 1; j < len; j++)
            {
                if(j > i + 1 && nums[j] == nums[j - 1]) // 防止第二个数重复计算
                {
                    continue;
                }
                // 双指针遍历剩下的两数之和
                long long newTarget = static_cast<long long>(target) - nums[i] - nums[j];
                int left = j + 1;
                int right = len - 1;
                
                while(left < right)
                {
                    if(static_cast<long long>(nums[left]) + nums[right] > newTarget)
                    {
                        right--;
                    }
                    else if(static_cast<long long>(nums[left]) + nums[right] < newTarget)
                    {
                        left++;
                    }
                    else
                    {
                        ret.insert({nums[i], nums[j], nums[left], nums[right]});
                        left++;
                        right--;
                        
                        // 跳过重复的元素
                        while(left < right && nums[left] == nums[left - 1])
                        {
                            left++;
                        }
                        while(left < right && nums[right] == nums[right + 1])
                        {
                            right--;
                        }
                    }
                }
            }
        }
        
        vector<vector<int>> ans(ret.begin(), ret.end());
        return ans;
    }
};