【数据结构】Leetcode——哈希表 经典题

---

开始之前学习一个单词热热身：

     hash 英[hæʃ]
     n. (回锅) 肉丁土豆; (尤指电话上的) #号;
     v. 反复推敲; 仔细考虑; 把……弄糟（乱）; 斩碎; 斩（肉）; 剁（肉）; 细切（肉）;
     [例句]The Government made a total hash of things and squandered a small fortune

---

     哈希表就是一种以 键-值(key-value) 存储数据的结构，只要输入key，即可查找到其对应的值。
     哈希表通过在value的存储位置和它的key之间建立一个确定的对应关系f（这个对应关系称为哈希函数），使每个key与数据结构中的一个唯一的存储位置相对应。
     一般哈希表都是用来快速判断一个元素是否出现集合里。

使用哈希查找有两个步骤：

1. 使用哈希函数将被查找的键转换为数组的索引。
2. 在理想的情况下，不同的键会被转换为不同的索引值，但是在有些情况下需要处理多个键被哈希函数映射到同一个索引值的情况，所以哈希查找的第二个步骤处理哈希碰撞冲突。哈希碰撞冲突的方法包括拉链法和线性探测法等。

     哈希表是一个在时间和空间上做出权衡的经典例子。如果没有内存限制，那么可以直接将键作为数组的索引。那么所有的查找时间复杂度为O(1)；如果没有时间限制，那么可以使用无序数组并进行顺序查找，这样仅需较少的内存。哈希表使用了适度的时间和空间来在这两个极端之间找到了平衡。只需要调整哈希函数算法即可在时间和空间上做出取舍。

C++中unordered_map与map的对比：

     unordered_map和map类似，都是存储key-value的值，可以通过key快速索引到value；

不同点：

1. unordered_map不会根据key的大小进行排序，而map中的元素是按照二叉搜索树存储，进行中序遍历会得到有序遍历，内部元素自动排序。

2. map的底层实现是二叉平衡树(红黑树)；hash_map的底层是一个hash_table；
   运行效率方面：unordered_map最高，而map效率较低但提供了稳定效率和有序的序列；
   占用内存方面：map内存占用略低，unordered_map内存占用略高，而且是线性成比例的。

3. c++中，map是红黑树，中序遍历有序；unordered_map是哈希表，属于无序存储。

---

1 两数之和(1)

题目：
     给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

思路：
     使用一个HashMap，来建立数字和其坐标位置之间的映射，HashMap是常数级的查找效率，我们在遍历数组的时候，用target减去遍历到的数字，就是另一个需要的数字了，直接在HashMap中查找其是否存在即可。

     unordered_map数据结构中用于查找的函数有count、find，其中find返回一个迭代器，指向第一个关键字为k的元素，若k不存在容器中，则返回尾后迭代器；count返回关键字等于k的元素的数量。（对于不允许重复关键字的容器，返回值永远是0或1）

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

2 存在重复元素(217)

题目：
     给定一个整数数组，判断是否存在重复元素。
     如果任意一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。
思路：
     使用一个哈希表，遍历整个数组，如果哈希表里存在某数组元素，返回false，如果不存在，则将其放入哈希表中。

注意：
     这里是将整数作为哈希表的关键字(key)，它所映射的值我们并不关心，这里将映射值仅仅设为下标i（故这里使用unordered_set也可以）。因为find函数返回的是指向第一个关键字为key的元素，故只要find不指向哈希表的尾后元素，则说明哈希表中存在关键字为key的元素，则说明有重复元素。

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        int sz=nums.size();
        unordered_map<int, int> hash;
        for(int i=0; i<sz; i++){
            if(hash.find(nums[i])!=hash.end()) return true;
            else hash[nums[i]] = i;
        }
        return false;
    }
};

3 最长和谐子序列(594)

题目：
     和谐数组是指一个数组里元素的最大值和最小值之间的差别正好是1。
     现在，给定一个整数数组，你需要在所有可能的子序列中找到最长的和谐子序列的长度。
示例：

思路：
     将数组中的值存入哈希表中，其中key-value对应为数组的值-该值出现的次数。
     处理时利用count查找当前值+1这个key值在不在哈希表中，若在，则按照最大值更新ans即可。

class Solution {
public:
    int findLHS(vector<int>& nums) {
        int ans = 0;
        unordered_map<int, int> hash;
        for(auto &i: nums){
            hash[i]++;
        }
        for(auto &i: nums){
            if(hash.count(i+1))
                ans = max(ans, hash[i] + hash[i+1]);
        }
        return ans;
    }
};

4 最长连续序列(128)

题目：
     给定一个未排序的整数数组，找出最长连续序列的长度。

示例：

思路：
     首先将数组放入unordered_set中，注意unordered_set中仅能存放互不相同的key值，之后同样利用count在容器中遍历寻找，若找不到当前元素值－1，则说明当前元素值为第一个连续序列起始值，则从该值起不断寻找与当前元素值连续的值且记录长度。

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        int res=0;
        unordered_set<int> st;
        for(auto &i:nums){
            st.insert(i);
        }
        for(int i=0; i<nums.size(); i++){
            if(!st.count(nums[i]-1)){
                int num = nums[i];
                int cnt=0;
                while(st.count(num)){
                    cnt++;
                    num++;
                }
                res = max(res, cnt);
            }
        }
        return res;
    }
};

5 两个数组的交集I(349)

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

思路：
     将nums1中的数放入unordered_set中，然后遍历nums2的元素，如果在unordered_set中存在，则说明是两个数组的交集，将该元素存入vector中，注意值的处理的是可以利用unordered_set中元素互不相同的性质将vector中相同元素删去，最终再次输出vector即可。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> res;
        unordered_set<int> st(nums1.begin(), nums1.end());
        for(int i=0;i<nums2.size();i++){
            if(st.find(nums2[i])!=st.end()){
                res.push_back(nums2[i]);
            }
        }
        unordered_set<int> st2(res.begin(), res.end());
        return vector<int>(st2.begin(), st2.end());
    }
};

6 两个数组的交集II (350)

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

思路：
     利用unordered_map存储nums1中元素出现的次数，在遍历nums2数组过程中，若找到相同元素，则将该元素存入vector中并且将unordered_map中存储该元素的次数减1，防止出现vector中元素数量与原始实参中的元素出现个数不一的情况。

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        vector<int> res;
        unordered_map<int, int> hash;
        for(auto & num: nums1) hash[num]++;
        for(auto &num: nums2){
            if(hash[num]-- > 0){
                res.push_back(num);
            }
        }
        return res;
    }
};

7 四数相加 II(454)

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

示例：

思路：
     用两个unordered_map分别记录AB和CD中两两之和出现次数，然后遍历其中一个哈希表，并在另一个哈希表中找和的相反数出现的次数，两个unordered_map中包含次数相乘即为出现的总次数。

class Solution {
public:
    int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
        unordered_map<int, int> hash1;
        unordered_map<int, int> hash2;
        int res=0;
        for(int i=0; i<A.size(); i++){
            for(int j=0; j<A.size(); j++){
                hash1[A[i]+B[j]]++;
                hash2[C[i]+D[j]]++;
            }
        }
        for(auto m :hash1){
            res += m.second * hash2[-m.first];
        }
        return res;
    }
};

8 快乐数(202)

题目：
     编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。如果 可以变为 1，那么这个数就是快乐数。
如果 n 是快乐数就返回 True ；不是，则返回 False 。

示例：

思路：
     题目中讲到无限循环，那么也就是说求和的过程中，sum会重复出现，故可通过将sum存入unordered_set中来作为循环截止条件。还需注意对某一数字逐位求和的过程，取余用%，整除用/。

class Solution {
public:
    int getsum(int n){
        int sum=0;
        while(n){
            int temp=(n%10)*(n%10);
            sum +=temp;
            n = n/10;
        }
        return sum;
    }
    bool isHappy(int n) {
        unordered_set<int> st;
        int temp = getsum(n);
        while(1){
            if(temp==1) return true;
            else if(st.find(temp)!=st.end()) return false;
            else {
                st.insert(temp);
                temp = getsum(temp);
            }
        }
        return false;
    }
};

欢迎关注【OAOA】