代码训练营第6天｜哈希表1｜leetcode242 字母异位词｜leetcode349 两个数组交集｜leetcode202 快乐数

本文链接：https://blog.csdn.net/weixin_44442376/article/details/132800277

理论文章：哈希表1

leetcode242:字母异位词

文章讲解：leetcode242

leetcode349：两个数组交集

文章讲解：leetcode349

leetcode202：快乐数

文章讲解：leetcode202

leetcode1: 两数之和

文章讲解：leetcode1

1，c++哈希表集合总结：

2，leetcode242 有效的字母异位词

2.1，第一发

2.2，节省空间

3，leetcode 349 两个数组的交集

3.1，差不多的思路：

3.2，没想起来set的原因：忘了怎么用：

4，leetcode 202 快乐数

5，leetcode1 两数之和：

6，总结

1，c++哈希表集合总结：

2，leetcode242 有效的字母异位词

2.1，第一发

复习完哈希表后思路就有了，先看单词长短，再统计每个字母出现的次数。而字数统计可以使用哈希表。这里有一个方法就是，由于英文字母并且都是小写，最多只有26个，用数组当作哈希表是最合适的。

class Solution {
public:
    bool isAnagram(string s, string t) {
        if(s.length()!=t.length()){
            return false;
        }
        int smap[26] = {0};
        int tmap[26] = {0};
        for(char& c:s){
            smap[c-'a'+0]++;
        }
        for(char& c:t){
            tmap[c-'a'+0]++;
        }
        for(int i = 0;i<26;i++){
            if(smap[i]!=tmap[i])return false;
        }
        return true;
    }
};

2.2，节省空间

在这道题里，两个哈希表有点多余：随想录给出的代码如下：

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26] = {0};
        for (int i = 0; i < s.size(); i++) {
            // 并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
            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) {
                // record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return false;
            }
        }
        // record数组所有元素都为零0，说明字符串s和t是字母异位词
        return true;
    }
};

一个加一个减，最后只要看没有0，就是出现不同次的字母。节省了一半的空间。

3，leetcode 349 两个数组的交集

3.1，差不多的思路：

注意题目提示：

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

意味着可以用数组，和上面那个一样了。只不过这次应该确实需要两个数组哈希表了：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        int nums1map[1001] = {0};
        int nums2map[1001] = {0};
        vector<int> result;
        for(int& x:nums1){
            nums1map[x]++;
        }
        for(int& x:nums2){
            nums2map[x]++;
        }
        for(int i = 0;i<1001;i++){
            if(nums1map[i]!=0 && nums2map[i]!=0){
                result.push_back(i);
            }
        }
        return result;
    }
};

3.2，没想起来set的原因：忘了怎么用：

这道题其实本身适合用set集合来做，只是判断有没有，不需要数出有几个。但是stl有些已经忘了，没想起来。今天有时间还需要复习一下。

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

    }
};

4，leetcode 202 快乐数

这道题问题在于，如果模拟这个过程，终止条件不好证明出来，而且模拟的时间效率很低，但是哈希表我确实也没啥思路，直接看视频

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;
        while(1) {
            int sum = getSum(n);
            if (sum == 1) {
                return true;
            }
            // 如果这个sum曾经出现过，说明已经陷入了无限循环了，立刻return false
            if (set.find(sum) != set.end()) {
                return false;
            } else {
                set.insert(sum);
            }
            n = sum;
        }
    }
};

这道题使用set最大的意义在于去判断是否已经处于无限循环中，解决了模拟过程中需要记录每次计算结果和比较的过程。

5，leetcode1 两数之和：

这个比较熟悉了，以前好几次刷题都是从这道题开始，在这道题放弃。思路很简单，将加法做成减法，在数组中找另一个加数。

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++) {
            auto iter = map.find(target - nums[i]); 
            if(iter != map.end()) {
                return {iter->second, i};
            }
            map.insert(pair<int, int>(nums[i], i)); 
        }
        return {};
    }
};