C++ day6 哈希表 有效字母的异位词 两个数组的交集 快乐数 两数之和

题目1：242有效字母的异位词

题目链接：有效字母的异位词

对题目的理解

根据两个字符串s,t ，判断t，s中每个字符出现的次数是否向相同，假定字符串中只包含小写字母

自己的思路

当然是纯暴力解法，两层for循环，遍历两个字符串，累加每个字符出现的次数，最后做出比较，时间复杂度是O（n^2）

哈希表(数组)

字符串中只包含小写字母，那么26个小写字母a~z，ASCII码值是连续的，那么可以使用数组求解，将a~z映射到数组中0~25，通过减去a字符，那么就可以得到连续的0~25对应a~z

例如：'a'-'a' =0  'b'-'a'=1   z-'a' =25

先遍历第一个字符串映射的数组，若字符出现，则在该位置处加1,统计每个字母出现的频率；

然后遍历第二个字符串映射的数组，若与前一个字符串的相同字符出现，则在该位置处减1；

最后，遍历整个映射的数组，判断其是否是一个全零数组，若是，那么说明是异位词

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

class Solution {
public:
    bool isAnagram(string s, string t) {
        int hash[26] = {0};//定义初始哈希表，元素全为零，因为最后要判断哪些位置不是0
        for(int i = 0;i < s.size();i++){
            hash[s[i]-'a']++;
        }//统计第一个字符串每一个字母出现的频率
        for(int i=0;i<t.size();i++){
            hash[t[i]-'a']--;
        }
        for(int i=0;i<26;i++){
            if(hash[i]!=0)
            return false;
        }
        return true;
      
    }
};

补充：若数值范围可控且数值较小，那么使用哈希表的数组结构；

           若数值很大，则使用哈希表中的set;

           若key对应value，则使用map

使用数组来做哈希的题目，是因为题目限制了数值的大小。如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。直接使用set 不仅占用空间比数组大，而且速度要比数组慢，set把数值映射到key上都要做hash计算的。

题目2：349两个数组的交集

题目链接：两个数组的交集

对题目的理解

返回两个数组的交集，输出的元素唯一

自己的思路

遍历两个数组，将其相等的元素存储到一个新数组中，然后对于得到的新数组进行查询，查找是否存在相同的元素，如果存在，则进行覆盖操作。这个思路比较冗余，时间复杂度是O（n^2）不推荐

哈希表（set）

题目更改之前，并没有限定nums1和nums2的取值范围，所以使用set

使用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。

将nums1映射到哈希表unordered_set中，，然后使用nums2与哈希表中的unordered_set格式的nums1进行查询，若是找到了，则将找到的结果放到result中，注意最后返回的是数组

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

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result;   //unordered_set有去重功能
        unordered_set<int> nums_set(nums1.begin(),nums1.end());//将nums1数组转化为unordered_set
        for(int i=0;i<nums2.size();i++){
            if(nums_set.find(nums2[i])!=nums_set.end()) //nums2的元素在nums_set中出现过
            result.insert(nums2[i]);
        }
        return vector<int>(result.begin(),result.end());
    
    }
};

更改题目之后，将nums1和nums2的取值范围取到了0-1000之间，所以可以使用数组进行求解

哈希表（数组）

使用哈希表将数组nums1中元素作为哈希表的下标，这样一旦某个元素出现，就给对应下标的值赋1；使用nums2中元素作为下标进行查询，若是找到，则直接在result中insert这个值，注意最后返回的是数组。

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

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result;   //unordered_set有去重功能
        int hash[10005] = {0};
        for(int i=0;i<nums1.size();i++){
            hash[nums1[i]] = 1; 
        }
        for(int i=0;i<nums2.size();i++){
            if(hash[nums2[i]]==1)
            result.insert(nums2[i]);
        }
        return vector<int>(result.begin(),result.end());
    
    }
};

题目3：202快乐数

题目链接：快乐数

对题目的理解

判断一个数是不是快乐数

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

自己的思路

循环 （终止条件是平方和为1）  ：对10取余求模，求得正整数每个位上的数值，然后求解平方和，这种做法费时，不推荐，关于那个无限循环中隐藏的条件，自己没有想到。

哈希表（set）

无限循环，那么也就是说求和的过程中，sum会重复出现，这对解题很重要！当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。所以这道题目使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false， 否则一直找到sum为1为止。

由于取值很大，所以使用set，使用unordered_set效率更高

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

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> 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);//将sum放入到set中，便于后续寻找是否存在相同的元素,是使用set的关键
        }
        n = sum;
        }




    }
};

题目4：1 两数之和

题目链接：两数之和

对题目的理解

找出数组中的两个元素之和等于target的两个元素，返回其下标

自己的思路

暴力解法，遍历数组中的所有元素，两层for循环，进行元素相加查找，时间复杂度是O(n^2)，这种做法冗余，不推荐。

哈希表（map）

需要一个集合来存放我们遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，也就是 是否出现在这个集合，因此可以推断使用哈希表

判断一个元素是否遍历过，将遍历过的元素加到这个集合里，每次遍历一个新位置之后，就判断想要寻找的这个元素是否在这个集合里出现过，那么就可以使用哈希表

那么使用哈希表的哪一种呢？因为既使用元素，又使用下标，所以使用map合适，map里面保存两个值，key和value，map中存放遍历过的元素

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

使用数组和set来做哈希表的局限：

• 数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
• set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用

map的特点是：在最快的时间里查找key是否在map中出现过，因此key代表元素值，value代表下标值

使用map的哪种结构呢？使用unordered_map，它的存读效率是最高的。

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

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

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map <int, int> map;//(int,int)代表(key,value)
        for(int i=0;i<nums.size();i++){
            int s = target - nums[i];
            auto iter = map.find(s);
            if(iter!=map.end())//说明找到了匹配的元素
            return{iter->second,i};  //返回当前的下标和存储在map中满足条件的下标
            //如果没有找到，则继续向下遍历,将当前的key(元素)和value（下标）保存下来
            map.insert(pair<int,int>(nums[i], i));
        }
        return {};
        
    }
};

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