算法学习笔记6 | 242.有效的字母异位词、349. 两个数组的交集、202. 快乐数、1. 两数之和 | 代码随想录

242.有效的字母异位词

题目链接：242. 有效的字母异位词
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词

思路：
定义一个大小为26的全零数组arr，每个元素分别对应二十六个小写字母a-z。如果字符串s中出现某字母，则arr中对应的数值加一。如果字符串t中出现某字母，则arr中对应的数值减一。
如果两个字符串为有效的字母异位词，那么数组arr的每个元素应该为零。

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

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

349. 两个数组的交集

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

思路：
由于题目说数组中的元素小于等于1000，所以可以定义一个大小为1001的哈希表。如果nums1中出现了某数字，则将哈希表中对应的数改为1。再遍历nums2，如果所对应的哈希表中的数为1，则说明该数重复出现了，将该数插入交集数组并将哈希表中对应的数改为2。

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        int arr[1001] = {};
        vector<int> result;
        for (int i = 0; i<nums1.size();i++)
        {
            arr[nums1[i]] = 1;
        }
        for (int i = 0; i<nums2.size();i++)
        {
            if ((arr[nums2[i]])==1)
            {
                result.push_back(nums2[i]);
                arr[nums2[i]] = 2;
            }
        }
        return result;
    }
};

用unordered_set替代数组会更加简便，但是要注意set和vector之间的转换：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;
        unordered_set<int> st(nums2.begin(),nums2.end());
        for (int num : nums1)
        {
            if (st.find(num)!=st.end())
            {
                result_set.insert(num);
            }
        }
        vector<int> result(result_set.begin(),result_set.end());
        return result;
    }
};

202. 快乐数

题目链接：202. 快乐数
编写一个算法来判断一个数 n 是不是快乐数。
「快乐数」 定义为：
对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
如果这个过程 结果为 1，那么这个数就是快乐数。
如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

思路：
题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现。
所以这道题目使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false， 否则一直找到sum为1为止。

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

class Solution {
public:
    bool isHappy(int n) {
        int sum;
        unordered_set<int> st;
        while (1)
        {
            sum = 0;
            while (n)
            {
                sum += (n%10) * (n%10);
                n/=10;
            }
            if (sum == 1)
            {
                return true;
            }
            if (st.find(sum)!=st.end())
            {
                return false;
            }
            else
            {
                st.insert(sum);
            }
            n = sum;
        }
    }
};

1. 两数之和

题目链接：1. 两数之和
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。

思路：
因为本题，我们不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。
map目的用来存放我们访问过的元素，因为遍历数组的时候，需要记录我们之前遍历过哪些元素和对应的下标，这样才能找到与当前元素相匹配的（也就是相加等于target）。
在遍历数组的时候，只需要向map去查询是否有和目前遍历元素匹配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为map存放的就是我们访问过的元素。

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

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