算法DAY06

242、有效的字母异同位

因为都是小写字母，只要创建一个大小为26的数组，来记录字符串中每个字母出现的次数，第一个字符串让数组元素++，第二个让数组元素–，最后判断数字是否全为0.

code

class Solution {
public:
    bool isAnagram(string s, string t) {
        int num[26]={0};
        for(int i=0;i<s.size();i++){
            num[s[i]-'a']++;
        }
        for(int i=0;i<t.size();i++){
            num[t[i]-'a']--;
        }
        int i=0;
        for(int i=0;i<26;i++){
            if(num[i]!=0){
                return false;
            }
        }
        return true;
    }
};

49.字母异位词分组

方法一：排序后的字符串作为KEY，排序后相同的字符串放在同一个vector容器，vector容器作为哈希表的value，存放未排序的字符串

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string, vector<string>> mp;//key是排序之后的字符串，value是一个vector容器，存放排序后都相同的未排序字符串
        for (string& str: strs) {//对于vector strs中的每一个字符串
            string key = str;
            sort(key.begin(), key.end());
            mp[key].emplace_back(str);//emplace_back是vector的操作函数，向vector尾部添加一个元素
        }
        vector<vector<string>> ans;//存放哈希表中所有的value，也就是若干个vector容器
        for (auto it = mp.begin(); it != mp.end(); ++it) {
            ans.emplace_back(it->second);//向ans尾部插入哈希表的所有value
        }
        return ans;
    }
};

方法二：用一个大小为26的string来记录每个字符串字母的频次，作为key，value还是相同key的字符串，用vector存储，最后得到若干个vector

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string, vector<string>> mp;//key是一个大小为26的数组，value是一个vector容器，存放排序后都相同的未排序字符串
        
        for (string& str: strs) {//对于vector strs中的每一个字符串
            string num = string(26, '0') ;
            for(int i=0;i<str.size();i++){
                num[str[i]-'a']++;
            }
            mp[num].emplace_back(str);//emplace_back是vector的操作函数，向vector尾部添加一个元素
        }
        vector<vector<string>> ans;//存放哈希表中所有的value，也就是若干个vector容器
        for (auto it = mp.begin(); it != mp.end(); ++it) {
            ans.emplace_back(it->second);//向ans尾部插入哈希表的所有value
        }
        return ans;
    }
};

39.两个数组的交集

方法一：两个ubordered_set：num_set和result_set，num_set中放一个数组的值，有重复元素插入result_set，而result_set能确保答案是没有重复元素的

code

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;
        unordered_set<int> num_set(nums1.begin(),nums1.end());
        for(int num:nums2){
            if(num_set.count(num)==1){
                result_set.emplace(num);
            }
        }
        return vector<int> (result_set.begin(),result_set.end());
    }
};

方法二：如果数组给了大小限定N，可以用一个数组num[N],来记录nums1数组的元素，和哈希表类似，一个下标对应一个元素，同样有相同元素存入result_set，给结果去重。

code

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.快乐数

有一个函数专门去算n的各个位的数字的平方和sum，用哈希表记录得出的sum，若哈希表中已存在这个sum就说明会开始无限循环

code

class Solution {
public:
    long long getsum(int n){
        int sum=0;
        while(n){
            sum+=(n%10)*(n%10);
            n=n/10;
        }
        return sum;
    }
    bool isHappy(int n) {
        unordered_set<long long> set;
        while(1){
            long long sum=getsum(n);
            if(sum==1){
                return true;
            }else{
                if(set.count(sum))//哈希表中有这个数字了，说明会开始循环
                {
                    return false;//直接退出
                }else{
                    set.emplace(sum);
                    n=sum;
                }
            }
        }
    }
};

1.两数之和

vector.push_back(num);向容器尾部添加一个数。unordered_map.emplace(key)=value;添加一个键值对。哈希表中数组元素作为key,下标作为value。

code

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> map;
        vector<int> result;
        for(int i = 0; i < nums.size(); i++){
            int n=nums[i];
            int n2=target-n;
            if(map.count(n2)==1){
                result.push_back(i);
                result.push_back(map[n2]);    
            }else{
                map[nums[i]]=i;
            }
        }
        return result;
    }
};