代码随想录 9.25 || 哈希表 LeetCode 242.有效的字母异位词、349.两个数组的交集、202.快乐数、1.两数之和

242.有效的字母异位词

        给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

        注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

        分析题目可知，给定两个字符串，若两个字符串中的字母组成和出现频率相同，仅顺序不同，即为有效的字母异位词。我们可以通过哈希表，判断第一个字符串中的元素是否在第二个字符串中出现，两个字符串出现的频率是否相同。

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 i = 0; i < t.size(); i++) {
            record[t[i] - 'a']--;
        }
        for (int i = 0; i < 26; i++) {
            if (record[i] != 0) {
                return false;
            }
        }
        return true;
    }
};

        在上述代码中，因为字母一共有26个，我们可以将长度为26的整数数组，作为哈希表。首先，将字母元素映射为整数数组的下标，遍历第一个字符串，每出现一个字符，就将整数数组在对应下标处的值加1。然后，遍历第二个字符串，每出现一个对应的字符，就将对应下标处的值减1。如果最后作为哈希表的整数数组中元素和为0，则两个字符串互为字母异位词。

349.两个数组的交集

        给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。返回两个数组中的交集元素，返回结果唯一可以不考虑输出结果的顺序。要求我们找到两个数组中的交集，并去重。针对在某一个集合中找某个元素的任务，特别适合哈希表数据结构，这里我们使用c++中的unorder_set结构，unorder_set的底层由哈希表实现，在向unorder_set中添加元素时，如果有重复元素，unorder_set会自动忽略重复元素，十分适合处理本题。这里给出两种实现，一种是基于数组实现的哈希表，另一种是基于unorder_set的哈希表。

class Solution { // unordered_set实现
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());
    }
};


class Solution { // 数组实现
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    unordered_set<int> result_set;

    int hash[1024] = {0}; // 需要明确 nums1 和 nums2 的范围，从而定义数组的区间
    for (int i = 0; i < nums1.size(); i++) {
        hash[nums1[i]] = 1;
    }
    for (int i = 0; i < nums2.size(); i++) {
        if (hash[nums2[i]] == 1) {
            result_set.insert(nums2[i]);
        }
    }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

        在解法一种，我们首先定义了unordered_set<int>的result_set和nums_set存储结果变量和nums1，需要注意的是，通过unordered_set<int>存储的nums1已经去重了。然后遍历nums2中的每个元素，如果找到了相同的元素则将其存入result_set中，即使存入重复元素也没关系，unordered_set<int>会自动忽略重复元素。函数要求vector<int>类型的返回值，最后将result_set中的元素取出来，放入vector<int>中。

202.快乐数

编写一个算法来判断一个数 n 是不是快乐数。

「快乐数」 定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
• 如果这个过程 结果为 1，那么这个数就是快乐数。

        如果 n 是 快乐数 就返回 true ；不是，则返回 false 。当出现重复数的时候，就代表着出现了循环，此时直接返回false 即可。

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

    bool isHappy(int n) {
        unordered_set<int> set;
        int number = getSum(n);
        while(number != 1) {
            if (set.find(number) != set.end()) {
                return false;
            }
            set.insert(number);
            number = getSum(number);
        }
        return true;
    }
};

1.两数之和    

        给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。

        LeetCode第一题，可以通过嵌套循环，以O()的时间复杂度解决。在学习了哈希表之后，也可以通过unordered_map解决。为什么使用unordered_map而不是unordered_set？因为unordered_map可以存入key和value的键值对，而unordered_set只能存储一个元素。在本题中，我们可以遍历数组中的每个元素，因为target已知，可以通过寻找target-nums来解决问题。如果当前元素与我们此前遍历过得元素相加等于target，则返回当前元素下标和target-nums的下标。因此，我们不仅需要存储遍历过的元素的值，还需要存储其下标，所以使用unordered_map更便利。

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 {};
    }
};