算法训练（leetcode）第五天 | 242. 有效的字母异位词、349. 两个数组的交集、202. 快乐数、1. 两数之和

242. 有效的字母异位词

leetcode题目地址

建立hash表记录单词中每个字母的个数，若两串不一致则返回false，反之返回true。

时间复杂度： $O(n)$
空间复杂度： $O(n)$

// c++
class Solution {
public:
    bool isAnagram(string s, string t) {
        if(s.size() != t.size()) return false;
        unordered_map<char, int> hash;
        for(int i=0; i<s.size(); i++) {
            hash[s[i]]++;
            hash[t[i]]--;
        }
          
        for(auto it=hash.begin(); it!=hash.end(); it++)
            if(it->second != 0) return false;
        return true;
    }
};

349. 两个数组的交集

leetcode题目地址

创建哈希表记录nums1中出现的元素，遍历nums2数组，判断每个元素在哈希表中是否存在，若存在则放入结果列表。

时间复杂度： $O(n)$
空间复杂度： $O(n)$

// c+++
class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        vector<int> result;
        unordered_map<int, int> hash;
        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){
                hash[nums2[i]] = 0;
                result.emplace_back(nums2[i]);
            }
        }
        return result;
    }
};

202. 快乐数

leetcode题目地址

虽然是一道简单题，但是刚开始拿到题目也没有思路，不知道怎么处理题中所说的无限循环。

思路来源：代码随想录

创建哈希表记录每次操作过后的值，若出现重复则返回false，若n为1则返回true。

时间复杂度： $O(logn)$
空间复杂度： $O(logn)$

// c++
class Solution {

public:
    int cal(int n){
        int result=0;
        while(n){
            result += pow(n%10, 2);
            n/=10;
        }
        return result;
    }
    bool isHappy(int n) {
        unordered_map<int, int> hash;
        while(n!=1){
            if(hash[n]!=0) return false;
            hash[n]++;
            n=cal(n);
        }
        return true;
    }
};

1. 两数之和

leetcode题目地址

最初思路：
创建一个哈希表存储数组中每个元素的下标，再遍历数组从哈希表中查找target-nums[i]的下标返回。共遍历两趟，需要判断target-nums[i]的下标不等于i。

时间复杂度： $O(n)$
空间复杂度： $O(n)$

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

改进：
在一趟遍历中完成上述操作，省去了判断target-nums[i]的下标是否等于i。

时间复杂度： $O(n)$
空间复杂度： $O(n)$

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