算法记录 05 | 242.有效的字母异位词，349. 两个数组的交集，202. 快乐数，1. 两数之和

KXAKI-LEE

已于 2024-07-23 08:14:08 修改

阅读量550

点赞数 23

分类专栏：算法文章标签：哈希算法算法 leetcode 数据结构

于 2024-07-22 22:00:58 首次发布

本文链接：https://blog.csdn.net/weixin_45852269/article/details/140620759

版权

算法专栏收录该内容

5 篇文章 0 订阅

订阅专栏

今日更新题目：242.有效的字母异位词，349. 两个数组的交集，202. 快乐数，1. 两数之和

这两天的知识点主要跟哈希表有关，个人觉得还是挺简单的，关于哈希表的理论基础，这里只做一点点经验总结

由于哈希表基本都是调用STL库，所以不会就查 C++ 参考手册即可；
哈希表是根据关键码的值而直接进行访问的数据结构，根据前面定义可知，数组也是一种哈希表；
需要查询一个元素是否出现在集合中，用哈希表
由于数组需要事先确定大小，所以一般只用于可以事先知道大小，或题中明确说明大小范围的时候才使用数组
其余类型的哈希表使用，实际就是根据需求在下表选择即可

集合	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::set	红黑树	有序	否	否	O(log n)	O(log n)
std::multiset	红黑树	有序	是	否	O(logn)	O(logn)
std::unordered_set	哈希表	无序	否	否	O(1)	O(1)

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::map	红黑树	key有序	key不可重复	key不可修改	O(logn)	O(logn)
std::multimap	红黑树	key有序	key可重复	key不可修改	O(log n)	O(log n)
std::unordered_map	哈希表	key无序	key不可重复	key不可修改	O(1)	O(1)

242.有效的字母异位词

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

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的

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

思路

本体其实就是要看s中的元素是否都在t中出现，且可重复，只包含小写字母，这么一来就限定了大小，只需给出一个26个字母大小的数组，记录输入中每个字母出现的次数，输出时再看是否能清空数组使之全为 0 即可，至于如何建立索引，本文当然是默认大家知道ASCII码的知识。

class Solution {
public:
    // 时间复杂度: O(n)，空间复杂度: O(1)
    bool isAnagram(string s, string t) {
        int record[26] = {0};
        for(int i = 0; i < s.size(); i++)
            record[s[i] - 'a']++;
        for(int i = 0; i < t.size(); i++)
            record[t[i] - 'a']--;
        for(int i = 0; i < 26; i++)
            if(record[i] != 0)
                return false;
        return true;
    }
};

349. 两个数组的交集

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

示例 1：

输入：nums1 = [1,2,2,1], nums2 = [2,2]
输出：[2]

示例 2：

输入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出：[9,4]
解释：[4,9] 也是可通过的

思路

返回两个数组交集，基本想法就是把nums1丢进一个集合中，遍历nums2，从nums1中找相同元素。接着根据题目说的，输出元素唯一，不考虑结果顺序，另外也不需要考虑索引什么的，根据之前给的表格中挑选，符合条件的就是unordered_set了

class Solution {
public:
    //时间复杂度: O(n + m) m是最后要把 set转成vector
    //空间复杂度: O(n)
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> tmp_set(nums1.begin(), nums1.end());
        unordered_set<int> result_set;
        for(int num : nums2){
            if(auto search = tmp_set.find(num); search != tmp_set.end())
                result_set.insert(num);
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

202. 快乐数

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

「快乐数」 定义为：

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

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

示例 1：

输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

示例 2：

输入：n = 2
输出：false

思路

本题关键在于非快乐数会在求解过程中陷入无限循环，我们要判断的就是找出这个无限循环的起始点或者这个数本身是快乐数，无限循环就是要在一个没有重复的集合中，判断一个元素是否在集合中出现过，由此确定用哈希表。另外，很容易判断也无需 key-value 对，根据上面提供的表格和以上条件确定使用unordered_set。

接下来就是给出一个无限的 while 循环，有两个可以结束循环的条件：

找到快乐数，即每个位置上的数字的平方和为1，此时 return true;
在 unordered_set 中找到重复项，说明即将陷入无限循环，此时 return false;

class Solution {
public:
    // 时间复杂度: O(logn)，空间复杂度: O(logn)
    bool isHappy(int n) {
        unordered_set<int> nums;
        while(1){
            int sum = 0;
            while(n){
                sum += (n % 10) * (n % 10);
                n /= 10;
            }
            if(sum == 1){
                return true;
            }
            if(auto search = nums.find(sum); search != nums.end()){
                return false;
            }
            nums.insert(sum);
            n = sum;
        }
    }
};

1. 两数之和

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

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

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

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

只会存在一个有效答案

思路

本题暴力循环大家应该都想得到，当然还有一次遍历的方法，遍历时判断差值 target - nums[i] 是否在集合中（确定需要用哈希表），若存在则返回索引，若不存在则先加入集合，当遍历一遍后仍未找到符合要求的索引对，则返回空。

有了具体思路再来容器选型，题中要求返回索引，而上面思路又说需要判断差值是否在集合中，也就是需要以差值为key，索引为value，因此确定容器类型为map，同时又说只会存在一个有效答案，且任意顺序返回，由此可以确定选择 unordered_map。

class Solution {
public:
    //时间复杂度: O(n)，空间复杂度: O(n)
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> nums_map;
        for(int i = 0; i < nums.size(); i++){
            auto tmp = target - nums[i];
            if(auto search = nums_map.find(tmp); search != nums_map.end()){
                return {i, search->second};
            }
            nums_map.insert({nums[i], i});
        }
        return {};
    }
};