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

哈希表都是用来快速判断一个元素是否出现集合里，哈希表是根据关键码的值而直接进行访问的数据结构。

（1）数组

（2）set集合

没有重复元素，且无序用unordered_set

没有重复元素，但有序用set

有重复元素且有序用multiset

（3）map映射

一种key value的存储结构

242.有效的字母异位词

题目：代码随想录

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

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

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

说明: 你可以假设字符串只包含小写字母

定义一个数组叫做record用来上记录字符串s里字符出现的次数。

需要把字符映射到数组也就是哈希表的索引下标上，因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。

在遍历 字符串s的时候，只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。 这样就将字符串s中字符出现的次数，统计出来了。

那看一下如何检查字符串t中是否出现了这些字符，同样在遍历字符串t的时候，对t中出现的字符映射哈希表索引上的数值再做-1的操作。

那么最后检查一下，record数组如果有的元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符，return false。

最后如果record数组所有元素都为零0，说明字符串s和t是字母异位词，return true。

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. 两个数组的交集

题目描述：代码随想录

题意：给定两个数组，编写一个函数来计算它们的交集。

 自己的思路：遍历两个数组，如果有相同的元素，就加入到一个新数组中，但是这样会导致新数组中元素重复不唯一

unordered_set不允许有重复数值，且数值是无序的。所以 unordered_set本身相当于就有一个去重的操作。

代码随想录的思路：

把数组 1转换成哈希表(unordered_set)的形式，此时哈希表中存放的就是去重之后的元素，然后在哈希表中去查询有没有数组2中的元素，如果有，就把相应的元素加入到result里（定义一个unordered_set类型的result）

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        unordered_set<int> nums_set(nums1.begin(), nums1.end());
        for (int num : nums2) {
            // 发现nums2的元素 在nums_set里又出现过
            if (nums_set.find(num) != nums_set.end()) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

1.上述代码中的for (int num : nums2)是范围for循环等同于常规写法 for(int i=0;i<nums2.size();i++) 

2.C++11引入了范围for循环，用于更方便地遍历容器中的元素。这种循环提供了一种简单的方式来迭代容器中的每个元素，而不需要显式地使用迭代器或索引。

for (类型 变量名 : 容器) {

// 在这里使用一个变量名，表示容器中的每个元素

}

还可以使用auto关键字来让编译器自动推断元素的类型，这样代码会更通用

for (auto num : numbers) {

    std::cout << num << " ";

}

3.向集合中插入元素需要使用insert()方法

4.集合中删除元素需要使用erase方法

5.find() 方法用于查找特定元素是否存在于集合中，如果 find() 方法找到了要查找的元素，它会返回指向该元素的迭代器，如果未找到要查找的元素，它会返回一个指向集合的 end() 的迭代器，表示未找到。通过比较find()方法返回的迭代器是否等于 end()，可以确定集合中是否有查找的元素。

6.迭代器都拥有名为begin()和end()的成员，表示指向第一个元素和最后一个元素的下一个元素的迭代器（尾后迭代器）

7.最后要把set转换成vector,转换的写法记一下

这道题如果限制了数组的大小如下：

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

那么就可以用数组来做哈希表（哈希表要定义的比数组稍微大一点） 

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

或者： 

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
    unordered_set<int>result;
    int hash[1005]={0};
    for(int i=0;i<nums1.size();i++)
    {
        hash[nums1[i]]++;
    }
    for(int j=0;j<nums2.size();j++)
    {
        if(hash[nums2[j]]!=0)
        {
            result.insert(nums2[j]);
        }
    }
    return vector<int>(result.begin(),result.end());
}
};

202. 快乐数 

题目描述：代码随想录

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

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

如果 n 是快乐数就返回 True ；不是，则返回 False 。

示例：

输入：19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

一开始有点难懂

一共就两种情况：要么就是各位数字平方和最终等于1，是快乐数；要么就是经过几次替换之后，又等于其中的某次各位数字平方和，然后就开始了无限循环，一直也找不到1，不是快乐数。不可能是越来越大的数字，一直大到没头，这个需要分析一下。

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

分解一个整数并获取其各位数字

• 通过取余num % 10获取最后一位数字，%表示取模/取余运算，即一个整数除以另一个整数后的余数，最后一位是个位，无法被10整除，所以就成了余数，进而可以通过%取余运算取到。
• 使用整数除法 number /= 10 来去掉 number 的最后一位数字。这个过程会一直重复，直到 number 变成0为止。

1. 两数之和

题目描述：代码随想录

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

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

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
    for(int i=0;i<nums.size();i++)
    {
        for(int j=i+1;j<nums.size();j++)
        {
            if(nums[i]+nums[j]==target)
            {
                return int result[2] = {i,j};
            }
        }
    }
    }
};

使用map映射： 

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++) {
            // 遍历当前元素，并在map中寻找是否有匹配的key
            auto iter = map.find(target - nums[i]); 
            if(iter != map.end()) {
                return {iter->second, i};//注意这里的写法
            }
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int, int>(nums[i], i)); //写法注意一下
        }
        return {};//遍历结束还没有找到的话，就返回一个空集合
    }
};

pair<int, int>定义了键值对的数据类型是pair, C++中的pair类型会将两个不同的值组合成一个单元， 常用于存储键值对，创建pair的时候，也必须提供两个类型名，比如上面的pair对象，两个值的类型都是int， 在使用时通过first 和 second 成员来访问 pair 中的第一个和第二个元素, 它的 first 成员存储键，而 second 成员存储值。

 1.为什么会想到用哈希表？

2.用哈希表的哪种数据结构来存储数据呢？

用map,因为既要存储元素的值，又要存储元素的下标。查找key是否在map中出现过，所以key对应的应该是元素的值，value对应的是元素的下标。 使用unordered_map因为查询和增删的效率最高。

3.这道题中map用来存放遍历过的元素