day6 | 242.有效的字母异位词、349. 两个数组的交集、202. 快乐数、1. 两数之和

目录：

解题及思路学习

242.有效的字母异位词

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

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

示例 1:

输入:s = "anagram",t = "nagaram"
输出: true

思考：可以用数组来记录字符串中字母出现的次数。如果相等结果，则返回true。

class Solution {
public:
    bool isAnagram(string s, string t) {
        int hash[27] = {0};
        for (int i = 0; i < s.size(); i++) {
            hash[s[i] - 'a'] += 1;
        }
        for (int i = 0; i < t.size(); i++) {
            hash[t[i] - 'a'] -= 1;
        }
        for (int i = 0; i < 27; i++) {
            if (hash[i] != 0) return false;
        }
        return true;
    }
};

• 时间复杂度: O(n)
• 空间复杂度: O(1)

优化：26个英文字母，所以数组只需要26就行。

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

349. 两个数组的交集

https://leetcode.cn/problems/intersection-of-two-arrays/

给定两个数组 nums1 和 nums2 ，返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

思考：用一个unordered_set 记录nums1中的元素，如果nums2中的元素也出现了，则在result 中添加。

class Solution {
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 n: nums2) {
						// 发现nums2的元素 在nums_set里又出现过
            if (nums_set.find(n) != nums_set.end()) {
                result.insert(n);
            }
        }
        return vector<int> (result.begin(), result.end());
    }
};

• 时间复杂度: O(mn)
• 空间复杂度: O(n)

随想录：leetcode改了数组范围，所以可以用数组来做哈希表。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        int hash[1005] = {0}; // 默认数值为0
        for (int num : nums1) { // nums1中出现的字母在hash数组中做记录
            hash[num] = 1;
        }
        for (int num : nums2) { // nums2中出现话，result记录
            if (hash[num] == 1) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

• 时间复杂度: O(m + n)
• 空间复杂度: O(n)

202. 快乐数

https://leetcode.cn/problems/happy-number/

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

「快乐数」 定义为：

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

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

示例 1：

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

思考：用一个unordered_set 来记录出现过的结果，如果重复出现，表示该数不是快乐数。

class Solution {
public:
    // 取数值各个位上的单数之和
    int getSum(int n) {
        int sum = 0;
        while(n) {
            sum += (n % 10) * (n % 10);
            n = n / 10;
        }
        return sum;
    }

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

• 时间复杂度: O(logn)
• 空间复杂度: O(logn)

1. 两数之和

https://leetcode.cn/problems/two-sum/

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

思考：用一个unordered_map 来记录元素的下标及其对应的值。在遍历的时候find是否有对应的target-当前value值。有的话则返回对应下标。

因为判断是否出现过的find函数，查找的是map中的key值，所以判断元素是否出现，这个元素就要作为key，所以数组中的元素作为key，有key对应的就是value，value用来存下标。

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

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

• 时间复杂度: O(n)
• 空间复杂度: O(n)

复盘总结

个人反思

重点：

1、为什么会想到用和哈希表？ 当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。

2、关于哈希表的结构。

数组，当题目限制了数值的具体大小，则可以用数组的哈希结构。

set（集合）有去重的作用。而且如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。此时可以考虑set

map(映射） 有记录key和value的功能。需要使用 key value结构来存放，那么使用map正合适。

3、map中，find查找的是key值。所以在最后一题需要将key存放值，value存放下标。