哈希表简介

• 数组表示哈希表
• 标准库中的哈希表

242. 有效的字母异位词

• 使用数组作为哈希表，字母的ascall值是天然的哈希函数。

class Solution {
public:
    bool isAnagram(string s, string t) {
        int recode[26] = {}; // 使用空列表初始化，默认初始化为0
        for (auto& a : s) {
            recode[a - 'a'] += 1;
        }
        for (auto& b : t) {
            recode[b - 'a'] -= 1;
        }
        for (auto& c : recode) {
            if (c != 0)
                return false;
        }
        return true;
    }
};

349. 两个数组的交集

• 使用数组作为哈希表，要注意数据量要小，数据间不能太稀疏。否则会容纳不下或者造成内存的浪费。
• 使用std::unorder_set类型，更加普适。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        int recodeNums1[1001] = {};
        int recodeNums2[1001] = {};
        vector<int> result;

        for (auto& a : nums1) {
            recodeNums1[a] = 1;
        }
        for (auto& b : nums2) {
            recodeNums2[b] = 1;
        }

        for (int i = 0; i < 1001; ++i) {
            if (recodeNums1[i] == 1 && recodeNums2[i] == 1)
                result.push_back(i);
        }

        return result;
    }
};

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 元素是唯一的
        unordered_set<int> num_set(nums1.begin(), nums1.end());
        for (int num : nums2) {
            if (num_set.find(num) != num_set.end()) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

202.快乐数

• 涉及到判断一个数是否重复出现，要考虑使用哈希表。

class Solution {
public:
    int getSum(int n) {
        int result = 0;

        while (n) {
            result += (n % 10) * (n % 10);
            n = n / 10;
        }

        return result;
    }

    bool isHappy(int n) {
        unordered_set<int> recode;

        while (1) {
            int sum = getSum(n);
            n = sum;

            if (n == 1) {
                return true;
            }

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

1.两数之和

• 新建哈希表依次保存数据，保存前检查其值是否符合要求。
• 使用差值判断元素是否在哈希表内。

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

454.四数相加

• 通过分组，减少循环次数。
• 允许重复

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        unordered_map<int, int> umap;
        for (auto a : nums1) {
            for (auto b : nums2)
                umap[a + b] += 1; // 既可以创建，也可以赋值
        }

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

        return count;
    }
};

383.赎金信

• 类似字母异位词，能使用数组作为哈希表。

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

        for (auto i : ransomNote) {
            ran[i - 'a'] += 1;
        }

        for (auto j : magazine) {
            ran[j - 'a'] = ran[j - 'a'] == 0 ? 0 : ran[j - 'a'] - 1;
        }

        for (auto k : ran) {
            if (k != 0)
                return false;
        }

        return true;
    }
};

待续