代码随想录算法训练营第六天|242. 有效的字母异位词，349. 两个数组的交集，202.快乐数，1. 两数之和

242. 有效的字母异位词

力扣题目链接

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

示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true

示例 2: 输入: s = “rat”, t = “car” 输出: false

说明: 你可以假设字符串只包含小写字母。

思路

哈希映射：数组

• 首先判断两个字符串长度是否相等，不相等则直接返回false
• 若相等，初始化哈希数组int hash[26]={0};
• 遍历字符串s，对应位置的值++
• 遍历字符串t，对应位置的值–
• 遍历哈希表，若哈希表存在不为0的数值，返回false，否则返回true

代码

class Solution {
public:
    bool isAnagram(string s, string t) {
        int hash[26]={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;
    }
};

• 时间复杂度O(n)
• 空间复杂度O(S)，其中S为字符集大小，S=26

随着n的变化，所需开辟的内存空间并不会随着n的变化而变化，即此算法空间复杂度为一个常量O(1)

349. 两个数组的交集

力扣题目链接

题意：给定两个数组，编写一个函数来计算它们的交集。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MAgBOGK9-1669034108225)(https://cdn.nlark.com/yuque/0/2022/png/2495891/1669019962844-6ca0f782-299e-4597-9d1a-f3758e976a5c.png)]

说明： 输出结果中的每个元素一定是唯一的。 我们可以不考虑输出结果的顺序。

思路

1. 数组

2. set

• 将nums1数组转化为哈希表
• 遍历nums2数组，比较哈希表中是否存在，若存在，将其存放到结果set中

unordered_set 可以去重

代码

1. 数组

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        int nums[1000]={0};
        vector<int> ans;
        for(int i=0;i<nums1.size();i++)
            nums[nums1[i]]++;
        for(int i=0;i<nums2.size();i++)
            if(nums[nums2[i]]!=0){
                ans.push_back(nums2[i]);
                nums[nums2[i]]=0;
            }
        return ans;
        
    }
};

2. set

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;
        unordered_set<int> nums_set(nums1.begin(),nums1.end());
        for(int i=0;i<nums2.size();i++){
            if(nums_set.find(nums2[i])!=nums_set.end())
                result_set.insert(nums2[i]);
        }
        return vector<int>(result_set.begin(),result_set.end());
    }
};

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

直接使用set 不仅占用空间比数组大，而且速度要比数组慢，set把数值映射到key上都要做hash计算的。

202.快乐数

力扣题目链接

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

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

如果 n 是快乐数就返回 True ；不是，则返回 False 。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nuneXzlp-1669034108226)(https://cdn.nlark.com/yuque/0/2022/png/2495891/1669028172710-8e05b68f-7ee8-4833-b736-9ef51eb25c83.png)]

思路

关键：如果不是快乐数，那么求和的结果数字会重复出现（原因见力扣）

1. 哈希法

• 数位分离求平方和
• 如果下一个数字不在哈希集合中，添加它，反之意味处于一个循环中，返回false

2. 双指针法

• fast每次走两步，slow每次走一步，必然会在环中相遇
• 此时，判断是不是因为 1 引起的循环，是的话就是快乐数，否则不是快乐数

3. 数学

• 只有一个循环：4→16→37→58→89→145→42→20→44，所有其他数字都在进入这个循环的链上，或者在进入 1的链上。

代码

1.哈希法

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;
            else
                set.insert(sum);
            n=sum;
        }
    }
};

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

2. 双指针法

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) {
        int slow=n,fast=n;
        do{
            slow=getSum(slow);
            fast=getSum(getSum(fast));
        }while(slow!=fast);
        return slow==1;
    }
};

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

1. 两数之和

力扣题目链接

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9

所以返回 [0, 1]

思路

1. 暴力法

2. 哈希表

• 使用哈希法的时机：查询一个元素是否出现过，或者一个元素是否在集合中
• key value结构，key存放元素，value存放下标->使用map
• map用来存放遍历过的元素
• 寻找**target-nums[i]**是否出现过

代码

1. 暴力法

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

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

2. 哈希法

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

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