LeetCode刷题（C++）-哈希表

242.有效字母异位词

数量不大。直接用数组作为哈希表

class Solution {
public:
    bool isAnagram(string s, string t) {
        int hash[26]={0};
        for(int i = 0; i < s.size(); i++){
            hash[s[i] - 'a']++;
        }
        for(int i = 0; i < t.size(); i++){
            hash[t[i] - 'a']--;
        }
        for(int i = 0; i < 25; i++){
            if(hash[i] != 0){
                return false;
            }
        }
        return true;
    }
};

349.两个数组的交集

unordered_set方法：（能够自动去重，且数据量可以足够大）

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;
        unordered_set<int> nums_set(nums1.begin(),nums1.end());
        for(int num : nums2){
            if(nums_set.find(num) != nums_set.end()){
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

拓展

那有同学可能问了，遇到哈希问题我直接都用set不就得了，用什么数组啊。

直接使用set 不仅占用空间比数组大，而且速度要比数组慢，set把数值映射到key上都要做hash计算的。

不要小瞧 这个耗时，在数据量大的情况，差距是很明显的。

后记

本题后面 力扣改了 题目描述 和 后台测试数据，增添了 数值范围：

• 1 <= nums1.length, nums2.length <= 1000
• 0 <= nums1[i], nums2[i] <= 1000

所以就可以 使用数组来做哈希表了， 因为数组都是 1000以内的。

数组方法：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
       unordered_set<int> 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<int>(result_set.begin(), result_set.end());
    }
};

1.两数之和

哈希表用unordered_map，因为既要存数组里的值，又要存该值所在下标

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> result_map;
        for(int i = 0; i < nums.size(); i++){
            unordered_map<int, int>::iterator it = result_map.find(target-nums[i]);
            if(it!=result_map.end()){
                return {it->second, i};
            }else{
                result_map.insert(pair<int,int>(nums[i], i));
            }
        }
        return {};
    }
};

454.四数相加

四个数组，分成两组，这样子时间复杂度就是O(n^2)

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> res_map;
        int count = 0;//个数
        for(int num1 : nums1){
            for(int num2 : nums2){
                res_map[num1 + num2]++;
            }
        }
        for(int num3 : nums3){
            for(int num4 : nums4){
                if(res_map.find(0 - (num3 + num4)) != res_map.end()){
                    count += res_map[0 - (num3+num4)];
                }
            }
        }
        return count;
    }
};

15.三数之和

不同于两数之和和四数相加，哈希法比较麻烦，此处用双指针法

双指针法：（注意不能有重复的三元组，所以要进行去重操作）

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(); i++){
            //减枝处理
            if(nums[i] > 0){
                return res;
            }
            //去重i
            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[left] + nums[right] > 0){
                    right--;
                }
                else if(nums[i] + nums[left] +nums[right] < 0){
                    left++;
                }
                else{
                    res.push_back(vector<int>{nums[i], nums[left], nums[right]});

                     //对left和right去重
                    while(left < right && nums[left+1] == nums[left]) left++;
                    while(left < right && nums[right-1] == nums[right]) right--;

                    //找到对的答案时双指针同时收缩
                    left++;
                    right--;
                }
            }
        }
        return res;
    }
};

18.四数之和

和上题思路一样，多加了一层for循环，不过注意减枝的条件，上题可以直接nums[i]>0就减枝，但是此处target是不确定的，所以nums[i] > target && nums[i] >= 0的时候才能减枝，二级减枝同理。注意去重，以及溢出问题。

对于15.三数之和 (opens new window)双指针法就是将原本暴力O(n^{3)的解法，降为O(n}2)的解法，四数之和的双指针解法就是将原本暴力O(n^{4)的解法，降为O(n}3)的解法。（因为双指针法将时间复杂度：O(n^2)的解法优化为 O(n)的解法。也就是降一个数量级）。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> res;
        sort(nums.begin(),nums.end());
        for(int i = 0; i < nums.size(); i++){
            //一级减枝
            if(nums[i] > target && nums[i] >= 0) break;
            //去重
            if(i > 0 && nums[i] == nums[i-1]) continue;
            for(int j = i + 1; j < nums.size(); j++){
                //二级减枝
                if(nums[i] + nums[j] > target && nums[i] +nums[j] >= 0) break;
                //去重
                if(j > i + 1 && nums[j] == nums[j - 1]) continue;
                int left = j + 1;
                int right = nums.size() - 1;
                while(left < right){
                    //注意溢出问题
                    if(nums[i] + nums[j] > target - (nums[left] + nums[right])) right--;
                    else if(nums[i] + nums[j] < target - (nums[left] + nums[right])) left++;
                    else{
                        res.push_back(vector<int>{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--;
                        //找到答案时，双指针同时收缩
                        left++;
                        right--;
                    }
                }
            }
        }
        return res;
    }
};