哈希表1219

GOODCONG

已于 2022-12-20 16:32:36 修改

阅读量344

点赞数

文章标签：算法

于 2022-12-19 16:55:15 首次发布

本文链接：https://blog.csdn.net/GOODCONG/article/details/128373051

版权

要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。

哈希法也是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。

哈希表的实现，有三种方式：

数组，集合（set)，映射（map);

数组，没什么好讲的。

集合：

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

映射：

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

242:有效字母异位词；

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = {0};

        for(int i =0 ; i<s.size();i++){
            record[s[i] - 'a']++;
        }

        for(int j =0;j<t.size();j++){
            record[t[j] - 'a']--;
        }

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

错误点：

忘记减 ‘a';
C++ 中的 true 和 false 是小写，不是python 中的大写。

383: 赎金信

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        int recordA[26] = {0};
        int recordB[26] = {0};

        for(int i =0;i<ransomNote.size();i++){
            recordA[ransomNote[i] - 'a']++;
        }

        for(int j = 0;j<magazine.size();j++){
            recordB[magazine[j] - 'a']++;
        }

        for(int i = 0 ; i<26;i++){
            if(recordA[i] > recordB[i]){
                return false;
            }
        }
        return true;
    }
};

错误点：这题没有错误，原因：过于简单。

49：字母异位词分组；

题目：

思路1：排序

由于互为字母异位词的两个字符串包含的字母相同，因此对两个字符串分别进行排序之后得到的字符串一定是相同的，故可以将排序之后的字符串作为哈希表的键。

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string, vector<string>> mp;
        for (string& str: strs) {
            string key = str;
            sort(key.begin(), key.end());
            mp[key].emplace_back(str);
        }
        vector<vector<string>> ans;
        for (auto it = mp.begin(); it != mp.end(); ++it) {
            ans.emplace_back(it->second);
        }
        return ans;
    }
};

看不太懂代码；

看懂了，看懂了！！！！

思路二：计数

由于互为字母异位词的两个字符串包含的字母相同，因此两个字符串中的相同字母出现的次数一定是相同的，故可以将每个字母出现的次数使用字符串表示，作为哈希表的键。

由于字符串只包含小写字母，因此对于每个字符串，可以使用长度为 26 的数组记录每个字母出现的次数。需要注意的是，在使用数组作为哈希表的键时，不同语言的支持程度不同，因此不同语言的实现方式也不同。

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        // 自定义对 array<int, 26> 类型的哈希函数
        auto arrayHash = [fn = hash<int>{}] (const array<int, 26>& arr) -> size_t {
            return accumulate(arr.begin(), arr.end(), 0u, [&](size_t acc, int num) {
                return (acc << 1) ^ fn(num);
            });
        };

        unordered_map<array<int, 26>, vector<string>, decltype(arrayHash)> mp(0, arrayHash);
        for (string& str: strs) {
            array<int, 26> counts{};
            int length = str.length();
            for (int i = 0; i < length; ++i) {
                counts[str[i] - 'a'] ++;
            }
            mp[counts].emplace_back(str);
        }
        vector<vector<string>> ans;
        for (auto it = mp.begin(); it != mp.end(); ++it) {
            ans.emplace_back(it->second);
        }
        return ans;
    }
};

看不懂，看不懂！！！！！

349: 两个数组的交集

题目：

思路：主要要学会使用一种哈希数据结构：unordered_set，这个数据结构可以解决很多类似的问题。

unodered Set

无序集(unorder sets)是一种不按特定顺序存储唯一元素的容器，允许快速根据元素的值检索单个元素。

在unordered_set中，元素的值同时也是唯一标识它的键。键是不可变的，因此，unordered_set中的元素在容器中不能被修改，但是它们可以被插入和删除。

在内部，unordered_set中的元素并不按照任何特定的顺序排序，而是根据它们的散列值组织到桶中，从而允许根据它们的值直接快速访问单个元素(平均时间复杂度为常数)。

与set容器相比，Unordered_set容器通过键访问单个元素的速度更快，尽管它们通常在通过元素的子集进行范围迭代时效率较低。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> ans;
        unordered_set<int> A;
        unordered_set<int> B (nums1.begin(),nums1.end());

        for(int num : nums2){
            if( B.find(num) != B.end()){
                A.insert(num);
            }
        }
        return vector<int> (A.begin(),A.end());



    }
};

350:两个数组的交集 II

题目：

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        if(nums1.size() < nums2.size()) { return intersect( nums2 , nums1);}
        unordered_map<int,int> m ;
        for(int num : nums1){
            m[num]++;
        }

        vector<int> intersection;
        for(int num : nums2){
            if(m.count(num)){
                intersection.push_back(num);
                m[num]--;
                if(m[num] == 0){
                    m.erase(num);
                }
            }
        }
        return intersection;
    }
};

注意点：

第四行的返回，不需要加 “ &”；
第十二行，为什么是呢？考虑清楚。

202: 快乐数；

题目：

注意题目中的两个点：

第一：无限循环，意味着，中途会出现相同的数字。

第二：最后退出的数字是 1 .尤为重要。这是退出条件。

class Solution {
public:
    int get_sum(int n){
            int sum = 0;
            while(n){
                sum += (n%10)*(n%10);
                n = n/10;
            }
            return sum;
        }

    bool isHappy(int n) {
        unordered_set<int> A;
        
        while(1){
            int sum = get_sum(n);
            if (sum == 1) return true;

            if (A.find(sum) != A.end()){
                return false;
            }else{
                A.insert(sum);
            }
            n = sum;
        }
    }
};

1.俩数之和

思路：暴力搜索

思路2：指针

map目的用来存放我们访问过的元素，因为遍历数组的时候，需要记录我们之前遍历过哪些元素和对应的下表，这样才能找到与当前元素相匹配的（也就是相加等于target）

接下来是map中key和value分别表示什么。

这道题我们需要给出一个元素，判断这个元素是否出现过，如果出现过，返回这个元素的下标。

那么判断元素是否出现，这个元素就要作为key，所以数组中的元素作为key，有key对应的就是value，value用来存下标。

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

在遍历数组的时候，只需要向map去查询是否有和目前遍历元素比配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为map存放的就是我们访问过的元素。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map <int,int> map;
        for(int i = 0; i < nums.size(); i++) {
            // 遍历当前元素，并在map中寻找是否有匹配的key
            auto iter = map.find(target - nums[i]); 
            if(iter != map.end()) {
                return {iter->second, i};
            }
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int, int>(nums[i], i)); 
        }
        return {};
    }
};

454：四数相加II

题目：

思路：上述两数相加的拓展。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int,int> mm;
        for(int a :nums1){
            for (int b :nums2){
                mm[a+b]++;
            }
        }
        int count = 0;

        for(int c :nums3){
            for(int d: nums4){
                if(mm.find(0-c-d) != mm.end()){
                    count += mm[0-c-d];
                }
            }
        }
        return count;

    }
};

15：三数之和

题目：

思路：利用指针； i left 以及right

重点是，如何降重


class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());

        for (int i = 0; i < nums.size(); i++) {

            if (nums[i] > 0) {
                return result;
            }

            if (i > 0 && nums[i] == nums[i - 1]) {
                continue;
            }
            int left = i + 1;
            int right = nums.size() - 1;
            while (right > left) {

                if (nums[i] + nums[left] + nums[right] > 0) right--;
                else if (nums[i] + nums[left] + nums[right] < 0) left++;
                else {
                    result.push_back(vector<int>{nums[i], nums[left], nums[right]});

                    while (right > left && nums[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;

                    right--;
                    left++;
                }
            }
        }
        return result;

    }
};

18：四数之和

题目：

思路：对于上述三数之和的拓展。以及N数之和，都可以这样子来弄。

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>>ans;
        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((long) nums[i] + nums[j] + nums[left] + nums[right] > target){
                        right--;
                    }else if((long) nums[i] + nums[j] + nums[left] + nums[right] < target){
                        left++;
                    }
                    else{
                        ans.push_back(vector<int>{nums[i],nums[j],nums[left],nums[right]});
                        while(left < right && nums[right] == nums[right -1]){
                            right--;
                        }
                        while(left < right && nums[left] == nums[left+1]){
                            left++;
                        }
                        right--;
                        left++;
                    }
                }

            }
        }
        return ans;


    }
};

错误点：

为什么使用break；直接return 结果会错误 why?

为什么要大于0；第7 ，15行代码。why?