哈希表：数组、set、map作哈希表

LeetCode242. 有效的字母异位词

https://leetcode-cn.com/problems/valid-anagram/

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

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

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

思路

使用数组作为哈希表。

字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下表0，相应的字符z映射为下表25。

在遍历字符串s的时候，将 s[i] - ‘a’ 数组下标所在的数组元素做+1 操作即可，这样就将字符串s中字符出现的次数，统计出来了。

同样在遍历字符串t的时候，将 t[i] - ‘a’ 数组下标所在的数组元素做+1 操作

最后检查一下，如果record数组如果有元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符，return false；如果record数组所有元素都为零0，说明字符串s和t是字母异位词，return true。

class Solution 
{
public:
    bool isAnagram(string s, string t) 
    {
        auto sz1 = s.size();
        auto sz2 = t.size();
        if (sz1 != sz2) return false;

        vector<int> record(26, 0);
        for (size_t i = 0; i != sz1; ++i)
        {
            ++record[s[i] - 'a'];
        }
        for (size_t i = 0; i != sz2; ++i)
        {
            --record[t[i] - 'a'];
        }

        for (size_t i = 0; i != 26; ++i)
        {
            if (record[i] != 0)
            {
                return false;
            }
        }
        return true;
    }
};

LeetCode383. 赎金信

https://leetcode-cn.com/problems/ransom-note/

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。杂志字符串中的每个字符只能在赎金信字符串中使用一次。)

输入：ransomNote = "aa", magazine = "ab"
输出：false

输入：ransomNote = "aa", magazine = "aab"
输出：true

思路

使用数组作为哈希表。

与LeetCode242. 有效的字母异位词思路基本一致，唯一的区别是：

最后检查时，如果record数组中有元素小于0，则说明赎金信中出现了杂志中没有的字符，此时return false；其余情况return true

代码

class Solution 
{
public:
    bool canConstruct(string ransomNote, string magazine) 
    {
        vector<int> record(26, 0);
        for (size_t i = 0; i != magazine.size(); ++i)
        {
            ++record[magazine[i] - 'a'];
        }
        for (size_t i = 0; i != ransomNote.size(); ++i)
        {
            --record[ransomNote[i] - 'a'];
        }

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

LeetCode349. 两个数组的交集

https://leetcode-cn.com/problems/intersection-of-two-arrays/

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

说明：

• 输出结果中的每个元素一定是唯一的。
• 我们可以不考虑输出结果的顺序

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

思路

使用set作为哈希表。

关于set，C++ 给提供了如下三种可用的数据结构：

• std::set
• std::multiset
• std::unordered_set

std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表。使用std::unordered_set 读写效率是最高的(因为不需要对数据进行排序)，并且还不要让数据重复，所以选择std::unordered_set。

思路如图所示：

代码

class Solution 
{
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) 
    {
        //数组转换为无序列表
        unordered_set<int> s(nums1.begin(), nums1.end());

        unordered_set<int> resultSet;
        for (int num2 : nums2)
        {
            if(s.count(num2)) 
            {
                resultSet.insert(num2);
            }
        }
        vector<int> result(resultSet.begin(), resultSet.end());
        
        return result;
    }
};

LeetCode202. 快乐数

https://leetcode-cn.com/problems/happy-number/

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」定义为：

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

输入：19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

思路

使用set作为哈希表。

题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现。换句话说，如果sum如果重复出现，那么就说明该数求解快乐数的过程中会陷入无限循环，这时应return false

判断sum是否重复出现就可以使用std::unordered_set。

代码

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

        return sum;
    }

public:
    bool isHappy(int n) 
    {
        unordered_set<int> s;
        while (1)
        {
            int sum = getSum(n);
            if (sum == 1)
            {
                return true;
            }
            
            if (s.count(sum))
            {
                return false;
            }
            else
            {
                s.insert(sum);
            }
            n = sum;
        }
    }
};

LeetCode1. 两数之和

https://leetcode-cn.com/problems/two-sum/

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

思路

使用map作为哈希表

前面几道题目展示了数组和set可以作哈希表，使用数组和set来作哈希表有如下局限性：

• 数组的大小是受限制的，而且如果元素很少，而key值太大会造成内存空间的浪费。
• set是一个集合，里面放的元素只能是一个key。

这道题目需要选择另一种数据结构：map ，map是一种key-value的存储结构，可以用key保存数组元素，用value在保存数组元素对应的数组下标。

关于map，C++ 给提供了如下三种可用的数据结构：

这道题目中并不需要key有序，选择std::unordered_map 效率最高。

代码

class Solution 
{
public:
    vector<int> twoSum(vector<int>& nums, int target) 
    {
        int sz = nums.size();
        
        vector<int> result = {-1 , -1};
        unordered_map<int, int> mp;
        for (int i = 0; i < sz; ++i)
        {
            if (mp.count(target - nums[i]))
            {
                result[0] = i;
                result[1] = mp[target - nums[i]];
                return result;
            }
            mp[nums[i]] = i;
        }

        return result;
    }
};

LeetCode454. 四数相加II

https://leetcode-cn.com/problems/4sum-ii/

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -228 到 228 - 1 之间，最终结果不会超过 231 - 1 。

输入:
A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]

输出:
2

解释:
两个元组如下:
1. (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

思路

使用map作为哈希表

这道题目是四个独立的数组，只要找到A[i] + B[j] + C[k] + D[l] = 0就可以，不用考虑有重复的四个元素相加等于0的情况。具体实现细节见代码注解。

代码

class Solution 
{
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) 
    {
        //定义一个map，key存储A，B中任意两个值的和，value存储该和出现的次数
        unordered_map<int, int> m;
        for (int a : A)
        {
            for (int b : B)
            {
                ++m[a + b];
            }
        }

        //遍历C,D，如果0-(c+d)在map中出现过的话，就把map中key对应的value(即出现的次数)统计出来
        int count = 0;
        for (int c : C)
        {
            for (int d : D)
            {
                if (m.count(-c-d))
                {
                    count += m[-c-d];
                }
            }
        }

        return count;
    }
};