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

242.有效的字母异位词

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

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

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

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

方法一-数组实现哈希表

class Solution {
public:
    bool isAnagram(string s, string t) {
        int record[26]={0};
        for(int i =0;i<s.size();i++)
        {
            record[s[i]-'a']++;         //记录对应的位置,无需计算ASCALL
        }
        for(int i =0;i<t.size();i++)
        {
            record[t[i]-'a']--;         //将t字符串中的减去
        }

        for(int i =0;i<26;i++)
        {
            if(record[i]!=0) return false;   //当都为0时代表俩个字符串相同
        }
        return true;
    }
};

思考：

• 利用数组下标来对俩个字符串分别进行统计
• 利用 “record[-‘a’] ”表示26位的数组的下标就不用计算ASCALL了
• 当要求的范围较小时，使用数组来实现哈希表

方法二-排序比较

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

思考：直接将俩个字符串重新排序比较是否完全相同

349. 两个数组的交集

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

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

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

方法一-使用std::unordered_set哈希表来实现

unordered_set的其他成员方法

end()	返回指向容器中最后一个元素之后位置的正向迭代器
find(key)	查找以值为 key 的元素，如果找到，则返回一个指向该元素的正向迭代器；反之，则返回一个指向容器中最后一个元素之后位置的迭代器

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
       unordered_set<int>result_set;        //用set是为了set的天然去重功能
       unordered_set<int>nums(nums1.begin(),nums1.end());
       for(auto num :nums2)
       {
           if(nums.find(num)!=nums.end())   //此处判断用了find()和end()
           {
               result_set.insert(num);
           }
       } 
       return vector<int>(result_set.begin(),result_set.end());
    }
};

思考：思路便是将nums1中的存到哈希表nums中，然后将nums2遍历与nums比较

本题后面 力扣改了 题目描述 和 后台测试数据，增添了 数值范围：

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

所以就可以 使用数组来做哈希表了， 因为数组都是 1000以内的。

方法二-数组实现哈希表

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int>result_set;
        int hash[1005]={0};
        for(auto num :nums1)
        {
            hash[num]=1;
        }
        for(auto num :nums2)
        {
            if(hash[num]==1)
            {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(),result_set.end());
    }
};

思考：将nums1中的值对应在hash表中赋值为1，在nums2中遍历，查找到==1则Insect进result数组。

202. 快乐数

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

「快乐数」 定义为：

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

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

输入： n = 2
输出： false

方法一-哈希表

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;

            if(set.find(sum) !=set.end())
            {
                return false;           //若sum出现过则说明进入了死循环
            }
            else
            {
                set.insert(sum);
            }
            n=sum;
        }
    }
};

思考：
当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。
所以这道题目使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false， 否则一直找到sum为1为止。
判断sum是否重复出现就可以使用unordered_set。
[# C++常用语法——unordered_set]((47条消息) C++常用语法——unordered_set_还没想好~的博客-优快云博客_unordered_set 头文件)

1. 两数之和

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

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

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

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

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

方法一-暴力解法

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

};

方法二-哈希表

map ，map是一种key value的存储结构，可以用key保存数值，用value在保存数值所在的下标。
std::unordered_map 底层实现为哈希表，std::map 和std::multimap 的底层实现是红黑树。
同理，std::map 和std::multimap 的key也是有序的
这道题目中并不需要key有序，选择std::unordered_map 效率更高！
接下来需要明确两点：

• map用来做什么
• map中key和value分别表示什么

map目的用来存放我们访问过的元素，因为遍历数组的时候，需要记录我们之前遍历过哪些元素和对应的下表，这样才能找到与当前元素相匹配的（也就是相加等于target）

接下来是map中key和value分别表示什么。

这道题 我们需要 给出一个元素，判断这个元素是否出现过，如果出现过，返回这个元素的下标。

那么判断元素是否出现，这个元素就要作为key，所以数组中的元素作为key，有key对应的就是value，value用来存下标。

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

在遍历数组的时候，只需要向map去查询是否有和目前遍历元素比配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为map存放的就是我们访问过的元素。

it->first 表示的是这个元素的key的值；

it->second 表示的是这个元素的value的值。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
       std::unordered_map<int,int> map;
       // 这里使用unordered_map而不用map的原因：unordered_map内部实现了哈希表，建立耗时较多，但是查找时间非常短，这题我们需要频繁查找，所以使用unordered_map
       for(int i=0;i<nums.size();i++)  //  遍历当前元素，并在map中寻找是否有匹配的key
       {
           auto it = map.find(target-nums[i]);
           if(it !=map.end())   //it !=map.end()则表示有匹配的值
           {
               return{it->second,i};
           }
           // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int, int>(nums[i], i)); 
       } 
       return {};
    }
};

四个重点：

• 为什么会想到用哈希表
• 哈希表为什么用map
• 本题map是用来存什么的
• map中的key和value用来存什么的