代码随想录算法训练营第五天 | 242.有效的字母异位词 349. 两个数组的交集 202. 快乐数 1. 两数之和

哈希表基础

今天开始考察哈希表知识，哈希表也叫散列表，一般哈希表都是用来快速判断一个元素是否出现在集合里。

在使用哈希表的时候，一般可以选择三种数据结构：数组、set（集合）、map（映射）。而在c++中，set和map又分别有三种数据结构可供选择。

std::unordered_set 底层实现为哈希表，无序，数值不能重复且不能更改，查询、增删效率高。
std::set 和 std::multiset 的底层实现是红黑树，红黑树是一种平衡二叉搜索树，所以key值是有序的，但key不可以修改，改动key值会导致整棵树的错乱，所以只能删除和增加。

std::unordered_map 底层实现为哈希表，同理，无序，不能重复且不能修改，查询、增删效率高。
std::map 和 std::multimap 的底层实现是红黑树。同理，std::map 和std::multimap 的key也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）。

总结一下，当需要快速判断一个元素是否出现在集合中时，就可以考虑哈希法。当集合长度确定且可以表示时，可以考虑使用数组数据结构，当集合长度不确定时可以考虑set数据结构，当需要存储两个值（如：数值与其下标）时，可以考虑map数据结构，在明天的打卡中会出现~

当然，虽然哈希法是牺牲了空间换取了时间，该用时还得用。

---

242.有效的字母异位词

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

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

示例 1:
输入: s = “anagram”, t = “nagaram”
输出: true

示例 2:
输入: s = “rat”, t = “car”
输出: false

提示:
1 <= s.length, t.length <= 5 * 104
s 和 t 仅包含小写字母

---

思路：这道题可以理解为：在s中出现过的字符在t中是否出现，若都出现了则互为字母异位词。故可以考虑使用哈希表来解决这道题。

并且本题中需要存储的出现过的数值是字母，且仅包含小写字母，所以可以使用数组实现哈希表，且表长为26，巧妙利用字母的ASCII值的差作为表的索引，表中存储字母出现的次数。在遍历s时将字母出现的次数存入哈希表中，在遍历t时对哈希表中的字母出现的次数做--操作，最终检查哈希表，如果有一个为值为不为0，则表示两个字符串不互为字母异位词。

C++版本

class Solution {
public:
    bool isAnagram(string s, string t) {  // 用哈希表存储字符出现次数
        int hash[26] = {0};  // 元素较少，用数组作为哈希表即可，并且用数组很快
        for (int i = 0; i < s.size(); i++) {
            hash[s[i] - 'a']++;  // 用s[i]处的字符-'a'得到相对于字符'a'的序号。eg.'a'-'a'=0。正好用于哈希表的索引
        }
        for (int i = 0; i < t.size(); i++) {
            hash[t[i] - 'a']--;  // 遍历第二个字符串时可以直接在原哈希表上操作，如果两个字符串互为字母异位，哈希表会回归全0
        }
        for (int i = 0; i < 26; i++) {
            // 如果判断等于0返回TRUE，那么会在第一个等于0的地方就返回TRUE结束了。
            // 所以应该判断不等于0的情况，有一个不为0就返回false！
            if (hash[i] != 0) {
                return false;
            }
        }
        return true;
    }
};

在for循环中判断返回条件时，只要有一个满足条件就返回输出了，要谨慎选择使用哪种条件来判断。

---

349. 两个数组的交集

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

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

示例 2：
输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的

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

---

思路：本题翻译一下就是，nums1中出现过的元素是否在nums2中出现，相同元素不用重复记录，最终返回两个数组中都出现过的元素，其实与第一题类似。

本题的数组长度不大于1000，可以使用数组实现哈希表，也可以使用set实现哈希表，这题试一下set数据结构。为了效率，选用unordered_set数据结构。将nums1存入哈希表，在遍历nums2时查找哈希表，找到两数组中的重复元素后将其插入另一个结果集中，并自动去重，最终返回结果集。

C++版本

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        // 使用unordered_set数据结构解决
        unordered_set<int> result_set; // 用于存放结果
        unordered_set<int> nums_set(nums1.begin(), nums1.end());  // 将数组nums1存入nums_set集合，并自动去重

        for (int num : nums2) {
            // find(num)查找值为num的元素，如果找到，则返回一个指向该元素的正向迭代器
            // 反之，则返回一个指向容器中最后一个元素之后位置的迭代器，也就是end()
            if(nums_set.find(num) != nums_set.end()) {  // 找到了重复元素
                result_set.insert(num);  // 将结果放入result_set集合，并自动去重
            }
        }
        return vector<int> (result_set.begin(), result_set.end());  // 转化为数组输出
    }
};

由于本题的数组不超过1000个数，也可以使用数组构建哈希表来解决，可尝试一下

---

202. 快乐数

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

「快乐数」 定义为：

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

示例 1：
输入：n = 19
输出：true
解释：
1² + 9² = 82
8² + 2² = 68
6² + 8² = 100
1² + 0² + 0² = 1

示例 2：
输入：n = 2
输出：false

---

思路：本题需要写一个死循环不停的进行平方和计算，在找到符合或不符合条件的时候跳出循环。

这里Carl哥讲了一个很巧妙的思路：将每次循环得到的平方和存入哈希表中，并且每次循环得到平方和都去哈希表中查找否是存在，如果这个平方和存在于表中，说明这个和之前出现过，说明计算进入的循环，是不可能得到最后的1，即可返回false，若得到的平方和为1，则返回true。

由于不知道多少次循环才能得到结果，所以哈希表长度不确定，可使用set数据结构，故选用unordered_set数据结构。

C++版本

class Solution {
public:
    int get_sum(int n) {
        // 因为每次要计算的平方和都不太一样
        // 所以首先设计一个函数计算每位数的平方和sum
        int sum = 0;
        while (n) {
            sum += (n % 10) * (n % 10);  // 每次都加上个位的平方
            n = n / 10;
        }
        return sum;
    }
    bool isHappy(int n) {
        // 利用哈希表记录sum值，如果出现重复，说明结果不可能为1，返回false
        // 如果出现1，则返回true
        // 循环结束的条件就是有返回值，所以应该写一个死循环
        unordered_set<int> sum_set;
        while(1) {
            int sum = get_sum(n);  // 计算n的每位数平方和
            if (sum == 1) {  // 如果sum为1 返回true
                return true;
            }
            else if (sum_set.find(sum) != sum_set.end()) {  // 如果找到了重复的sum，说明不可能得到sum为1，返回false
                return false;
            }
            else {
                sum_set.insert(sum);  // 没有重复也不为1，将sum值存入哈希表
            }
            n = sum;  // 进行下一轮计算
        }
    }
};

这个思路很巧妙，要注意多复习！

---

1. 两数之和

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

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

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

示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：
输入：nums = [3,3], target = 6
输出：[0,1]

---

思路：本题可以将遍历过的数存入哈希表中，并在遍历过程中查找表中是否存在与当前数相加和为target的数，若有则返回这两个数的下标。

由于还需要存储下标，则应采用map这种key-value数据结构，由于查找表的时候是找数值，所以key用来存放数值，value用来存放下标。

C++版本

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        // 可使用哈希表存放遍历过的数值，在每遍历一个数值时查询表中是否存在与该数值相加等于target的数，若存在则返回这两个数的下标
        // 因为需要存放下标和数组值，这里使用map数据结构构建哈希表，unordered_map效率更高
        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));  // 由于查找的是数值，所以将数值作为key，下标作为value
        }
        return {};
    }
};

leetcode第一题就不简单啊，加油