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

最新推荐文章于 2024-10-05 12:07:50 发布

DayDayUp_._

最新推荐文章于 2024-10-05 12:07:50 发布

阅读量1.2k

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_40308499/article/details/130759996

版权

文章介绍了使用C++编程语言实现几种算法问题的解决方案，包括判断两个字符串是否为字母异位词、找出两个数组的交集以及判断一个数是否为快乐数。这些方法主要利用哈希表（如数组和unordered_set）来高效地处理数据和检查重复项。

摘要由CSDN通过智能技术生成

242. 有效的字母异位词

题目：

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

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

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

思路：

数组其实就是一个简单哈希表，而且这道题目中字符串只有小写字符，那么就可以定义一个数组，来记录字符串s里字符出现的次数。大小为26 就可以了，初始化为0，因为字符a到字符z的ASCII是26个连续的数值。

第一个for循环用来记录s中的字母个数，每个字母对应的数组元素+1，第二个for循环用来记录t中的字母个数，每个字母对应的数组元素-1，如果数组中的所有元素不为0，说明不是字母异位词，否则是。

代码：

class Solution {
public:
    bool isAnagram(string s, string t) {
        int hash[26];
        for(int i = 0; i < 26; i++){
            hash[i] = 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; // record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
        }
        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] 也是可通过的

思路：

使用数组来做哈希表了，因为数组都是 1000以内的，思路同上题

代码：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;
        int hash[1005]= {0};
        for(int num : nums1) hash[num] = 1; // nums1中出现的字母在hash数组中做记录
        for(int num : nums2){ // nums2中出现话，result记录
            if(hash[num] == 1) result_set.insert(num);

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

思路：

关于set，C++ 给提供了如下三种可用的数据结构：

std::set
std::multiset
std::unordered_set

std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表，使用unordered_set 读写效率是最高的，并不需要对数据进行排序，而且还不要让数据重复，所以选择unordered_set。

代码：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set;
        unordered_set<int> num_set(nums1.begin(), nums1.end());
        for(int num : nums2){
            //num_set.find(num)查找值为num的元素，如果找到，就返回指向该元素的正向迭代器；反之，则返回尾后迭代器(结束迭代器)。
            // 发现nums2的元素 在nums_set里又出现过
            if(num_set.find(num) != num_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
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

示例 2：

输入：n = 2
输出：false

思路：

题目中说了会 无限循环，那么也就是说求和的过程中，sum会重复出现，这对解题很重要！

当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。

所以这道题目使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false，否则一直找到sum为1为止。

判断sum是否重复出现就可以使用unordered_set。

代码：

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：

输入：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]

思路：

当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

本题呢，我就需要一个集合来存放我们遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，也就是是否出现在这个集合。

那么我们就应该想到使用哈希法了。

因为本题，我们不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。

接下来需要明确两点：

map用来做什么
map中key和value分别表示什么

map目的用来存放我们访问过的元素，因为遍历数组的时候，需要记录我们之前遍历过哪些元素和对应的下标，这样才能找到与当前元素相匹配的（也就是相加等于target）

接下来是map中key和value分别表示什么。

这道题我们需要给出一个元素，判断这个元素是否出现过，如果出现过，返回这个元素的下标。

那么判断元素是否出现，这个元素就要作为key，所以数组中的元素作为key，有key对应的就是value，value用来存下标。

所以 map中的存储结构为 {key：数据元素，value：数组元素对应的下标}。

在遍历数组的时候，只需要向map去查询是否有和目前遍历元素匹配的数值，如果有，就找到的匹配对，如果没有，就把目前遍历的元素放进map中，因为map存放的就是我们访问过的元素。

代码：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        std::unordered_map <int,int> map;
        for(int i = 0; i < nums.size(); i++){
            int s = target - nums[i];
            auto iter = map.find(s); //C++中auto被定义为自动推断变量的类型
            if(iter != map.end()) return {i, iter->second};
            // 如果没找到匹配对，就把访问过的元素和下标加入到map中
            map.insert(pair<int, int>(nums[i], i)); 
        }
        return {};
    }
};