随想录二刷Day07——哈希表

哈希表

2. 有效的字母异位词

242. 有效的字母异位词

思路：
哈希表记录每个字符串中，每个字母的出现次数，所有字母出现次数相同，则返回 true，否则返回 false 。

class Solution {
public:
    bool isAnagram(string s, string t) {
        int word[26] = {0};
        int s_len = s.length();
        int t_len = t.length();
        for (int i = 0; i < s_len; i++) word[s[i] - 'a']++;
        for (int i = 0; i < t_len; i++) {
            word[t[i] - 'a']--;
            if (word[t[i] - 'a'] < 0) return false; // 优化
        }
        for (int i = 0; i < 26; i++) {
            if (word[i] != 0) return false;
        }
        return true;
    }
};

3. 两个数组的交集

349. 两个数组的交集

思路1：
开数字范围那么大的数组，统计 nums1 中每个数字是否出现过，遍历 nums2 ，如果 nums2 中的数字在 nums1 中出现过，则放入结果集，然后将该数字的出现过的标记抹除（防止重复添加）。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> ans;
        int nums1_size = nums1.size();
        int nums2_size = nums2.size();
        bool vis[1005] = {false};
        for (int i = 0; i < nums1_size; i++) vis[nums1[i]] = true;
        for (int i = 0; i < nums2_size; i++) {
            if (vis[nums2[i]] == true) {
                ans.push_back(nums2[i]);
                vis[nums2[i]] = false;
            }
        }
        return ans;
    }
};

思路2：
思路1 浪费的空间可能很大，可以使用 集合数据结构 来代替数组做哈希表。unordered_set 还有去重的作用。

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());
        int nums2_size = nums2.size();
        for (int i = 0; i < nums2_size; i++) {
            if (num_set.find(nums2[i]) != num_set.end()) {
                result_set.insert(nums2[i]);
            }
        }
        vector<int> ans(result_set.begin(), result_set.end());
        return ans;
    }
};

4. 快乐数

202. 快乐数

思路：
按照题意模拟运行过程，判断每次 n 是否出现过，如果出现过，说明出现循环小数，直接返回 false；否则继续模拟，直到出现循环 return false ，或者 n == 1 时，返回 true。

class Solution {
public:
    bool isHappy(int n) {
        unordered_set<int> vis;

        while (n != 1) {
            if (vis.find(n) != vis.end()) { // 如果找到了，说明有循环
                return false;
            } else vis.insert(n);

            int temp = n;
            n = 0;
            while (temp > 0) {
                n += pow(temp % 10, 2);
                temp /= 10;
            }
        }
        return true;
    }
};

5. 两数之和

1. 两数之和

思路：
定义一个哈希表，存的数据是 {target - nums[i], i} ，遍历 nums，如果某个数在哈希表中找到了，说明它和该位置之前遇到的数相加等于 target，返沪结果前一个数的下标和当前下标 {哈希表->second, i} 。

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

6. 四数相加 II

454. 四数相加 II

思路：
将 4 个数组合并成两个大数组（找出和的个数）。
然后和上一问相同的思路求解个数。

class Solution {
public:
    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
        int nums1_size = nums1.size(), nums2_size = nums2.size(), nums3_size = nums3.size(), nums4_size = nums4.size();
        int ans = 0;
        unordered_map<int, int> my_map;

        for (int a : nums1) {
            for (int b : nums2) {
                my_map[a + b]++;
            }
        }

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

        return ans;
    }
};

7. 赎金信

383. 赎金信

思路：
统计 magezine 中每个字符出现的次数，遍历 randsomNote 的字母，遇到一个，统计的哈希表中该字母数量 -1，如果出现某个字母统计数量小于 0，则说明不够用，返回 false， 否则返回 true。

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<char, int> my_map;

        for (char m : magazine) {
            my_map[m]++;
        }

        for (char r : ransomNote) {
            my_map[r]--;
            if (my_map[r] < 0) return false;
        }

        return true;
    }
};