刷题记录day5|242. 有效的字母异位词、349. 两个数组的交集、202. 快乐数、1. 两数之和

242.有效的字母异位词

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

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

242.有效的字母异位词

方法1：排序比较

直接分别排序，然后比较，但时间复杂度是O(logn)，注意：排序同样也需要O(logn)的空间复杂度。

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

方法2：哈希

首先比较字符串长度，不相等直接假

初始化一个长度为26的全部为0的数组，当遍历第一个字符串，将字符串元素放到对应数组下标

进行加加。遍历第二个字符串，进行减减操作。再次遍历数组，有非零元素就说明false，否则true。

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

349. 两个数组的交集

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

349.两个数组的交集

方法1：哈希

首先将nums1元素插入到哈希表中，然后对去重后的nums2数组去哈希表中查，查到就是交集元素，插入到结果数组中即可。注意：去除数组重复元素的常用方法就是先排序再去重。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> hash;
        vector<int> ans;
        for(int i = 0;i<nums1.size();i++){
            hash.insert(nums1[i]);
        }
        sort(nums2.begin(),nums2.end());
        for(int i = 0;i<nums2.size();i++){
            if(i>0&& nums2[i] == nums2[i-1]){
                continue;
            }
            if(hash.find(nums2[i])!= hash.end()){
                ans.push_back(nums2[i]);
            }
        }
        return ans;
    }
};

方法2：优化

重点在于学习这种写法，

 unordered_set<int> nums_set(nums1.begin(), nums1.end());

 直接将数组元素全部按顺序插入到set集合中。

return vector<int>(result_set.begin(), result_set.end());

 直接将集合中的元素再插入到vector向量中。

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

202. 快乐数

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

「快乐数」 定义为：

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

如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

202.快乐数

注意一下求每一位上的数字的方法

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. 两数之和 

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

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

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

1.两数之和

哈希。这里注意用到了迭代器，上一题目就没有用到迭代器。

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int> hash;
        vector<int> ans;
        for(int i  = 0;i<nums.size();i++){
            auto ite = hash.find(target-nums[i]);
            if(ite!=hash.end()){
                ans.push_back(i);
                ans.push_back(ite->second);
            }
            hash[nums[i]] = i;
        }
        return ans;
    }
};