代码随想录-Day6| 242.有效的字母异位词，349. 两个数组的交集， 202. 快乐数，1. 两数之和

242.有效的字母异位词

拿到题目先看input，分析给的题干，能让我们怎么省力，偷鸡
全是小写字母，一个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;
     }
 };

利用 algorithm sort

排序过后，如果是字母异位，那两个string肯定就一样

 class Solution {
 public:
     bool isAnagram(string s, string t) {
         sort(s.begin(),s.end());
         sort(t.begin(),t.end());
         if(s==t)
             return true;
         else
             return false;
     }
 };

两个数组的交集

unordered_set 的construct方法

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

能用数组还是用数组，不需要哈希运算，占用空间还小。

数组法

有相同的值，在数组里覆盖就覆盖了，我们不需要知道总共有几个，我们只需要知道里面有没有。

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

202. 快乐数

其实我也思考到了，题目的关键就是一个无限循环，然后整个哈希表判断cases
但是我想的是存已经出现过的数字，或者规律什么的
最后发现是要存sum
算法的标准之一就是，does it halt？
为什么会无限循环呢，我想的无限循环是每次加完结果都不一样，有很多个结果，但是想一想，翻来覆去也就是3位数加到2位数，再加到三位数，这不是一个单调的规律，既然这样它就会有高有低，这样一定会有重复。

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

1. Two sums

key放元素的值，value放下标，因为我们永远要把查找的放在key里。
iterator->second
vector initialize {};
直接return {}

答案

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

my

 class Solution {
 public:
     vector<int> twoSum(vector<int>& nums, int target) {
         unordered_map<int, int> hash;
         int i = 0;
         for (int element: nums){
             if (hash.find(target - element) != hash.end()){
                 return {i, (hash.find(target - element)->second)};
             }
             hash.insert({element, i});
             i++;
 
         }
         return {};
     }
 };