代码随想录第6天|有效的字母异位词、两个数组的交集、快乐数、两数之和

LU091

已于 2024-04-25 20:57:17 修改

阅读量1.9k

点赞数 34

分类专栏： leetcode 代码随想录哈希文章标签：哈希算法散列表算法

于 2024-04-25 20:56:25 首次发布

本文链接：https://blog.csdn.net/LU091/article/details/138198041

版权

代码随想录同时被 3 个专栏收录

4 篇文章 0 订阅

订阅专栏

leetcode

3 篇文章 0 订阅

订阅专栏

哈希

1 篇文章 0 订阅

订阅专栏

本文介绍了如何在编程中使用哈希表（如数组、unordered_set和map）解决LeetCode中的字母异位词判断、两个数组的交集查找以及快乐数问题，强调了哈希法在这些问题中的应用和数据结构的选择策略。

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

有效的字母异位词

什么是哈希

哈希表（英文名字为Hash table，国内也有一些算法书籍翻译为散列表，大家看到这两个名称知道都是指hash table就可以了）。

其实数组就是一张哈希表。

哈希表中关键码就是数组的索引下标，然后通过下标直接访问数组中的元素，如下图所示：

一般哈希表都是用来快速判断一个元素是否出现集合里。

更详细的内容可以移步这篇文章：代码随想录 (programmercarl.com)

题目链接：. - 力扣（LeetCode）

视频链接：学透哈希表，数组使用有技巧！Leetcode：242.有效的字母异位词_哔哩哔哩_bilibili

文章链接：代码随想录 (programmercarl.com)

本题比较简单易懂，主要思想就是

1、数组是哈希，用数组存储值最后来检验

2、遍历一个数组是hash数组++，遍历另一个数组是hash数组--;最后来看hash数组的每一个元素是否为0来判断是否是有效的字母异位词

主要操作

定义一个数组hash用来上记录字符串s里字符出现的次数。

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

需要把字符映射到数组也就是哈希表的索引下标上，因为字符a到字符z的ASCII是26个连续的数值，所以字符a映射为下标0，相应的字符z映射为下标25。

再遍历字符串s的时候，只需要将 s[i] - ‘a’ 所在的元素做+1 操作即可，并不需要记住字符a的ASCII，只要求出一个相对数值就可以了。 这样就将字符串s中字符出现的次数，统计出来了。

class Solution {
public:
    bool isAnagram(string s, string t) {
        int hash[26];
        int i;
        for(i=0;i<26;i++)//初始化Hash
        {
            hash[i]=0;
        }
        for(i=0;i<s.size();i++)//遍历数组s
        {
            hash[s[i]-'a']++;
        }
         for(i=0;i<t.size();i++)//遍历数组t
        {
            hash[t[i]-'a']--;
        }
         for(i=0;i<26;i++)//检验hash数组
        {
            if(hash[i]!=0) return false;
            
        }
        return true;//注意这句话不要写在for循环里面了，不然多次返回了；

    }
};

两个数组的交集

本题有两种写法

set（没有限制长度）

数组（限制了长度）

这道题目，主要要学会使用一种哈希数据结构：unordered_set，这个数据结构可以解决很多类似的问题。

注意题目特意说明：输出结果中的每个元素一定是唯一的，也就是说输出的结果的去重的，同时可以不考虑输出结果的顺序

set写法

如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。

关于set，C++ 给提供了如下三种可用的数据结构（可以当做数据类型使用，如int）：

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; // 存放结果，之所以用set是为了给结果集去重
        unordered_set<int> nums_set(nums1.begin(), nums1.end()); // 将 nums1 转换为集合，以便进行快速查找

        // 遍历 nums2 的每个元素
        for (int num : nums2) {
            // 如果 nums2 的元素在 nums_set 中存在
            if (nums_set.find(num) != nums_set.end()) {
                // 将该元素插入结果集
                result_set.insert(num);
            }
        }

        // 将结果集转换为向量并返回
        return vector<int>(result_set.begin(), result_set.end());
    }
};

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

不要小瞧这个耗时，在数据量大的情况，差距是很明显的。

数组写法

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int> result_set; // 存放结果，之所以用set是为了给结果集去重
        int hash[1005] = {0}; // 默认数值为0
        for (int num : nums1) { // nums1中出现的字母在hash数组中做记录
            hash[num] = 1;
        }
        for (int num : nums2) { // nums2中出现话，result记录
            if (hash[num] == 1) {
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(), result_set.end());
    }
};

快乐数

题目链接：. - 力扣（LeetCode）

文章链接：代码随想录 (programmercarl.com)

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

示例：

输入：19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

思路

这道题目看上去貌似一道数学问题，其实并不是！

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

正如：关于哈希表，你该了解这些！ (opens new window)中所说，当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了。

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

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

还有一个难点就是求和的过程，如果对取数值各个位上的单数操作不熟悉的话，做这道题也会比较艰难

判断方法

如果平方和为 1，说明该整数是快乐数，函数返回 true。

如果平方和曾经在之前的计算中出现过（即在 set 中已经存在），则说明该整数进入了一个无限循环，不可能得到快乐数，函数返回 false。

如果平方和不为 1 且没有出现过，则将平方和插入到 set 中，并将 n 更新为当前的平方和。继续下一轮循环，计算新的平方和。

`set.insert(sum)`

在代码中的 set.insert(sum) 语句的目的是将当前计算得到的平方和 sum 插入到 set 集合中。

这样做的目的是为了记录每次计算得到的平方和，以便后续判断是否进入了无限循环。通过将每次计算得到的和值插入到 set 中，我们可以使用集合的快速查找特性来判断当前的和值是否已经出现过

class Solution {
public:
    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;

        }

    }
    int getSum(int n){
        int sum=0;
        while(n){
            sum+=(n%10)*(n%10);
            n/=10;
        }
        return sum;
    }
};

两数之和

题目链接：https://leetcode.cn/problems/two-sum/

视频链接：梦开始的地方，Leetcode：1.两数之和，学透哈希表，map使用有技巧！_哔哩哔哩_bilibili

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

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

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

C++中map，有三种类型：

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

这道题目中并不需要key有序，选择std::unordered_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) {
        unordered_map<int, int> map; // 用于存储数字和其对应的索引
        for (int i = 0; i < nums.size(); i++) {
            auto iter = map.find(target - nums[i]); // 在 map 中查找与当前数字的差值对应的索引
            if (iter != map.end()) {
                // 如果找到了与当前数字的差值对应的索引，则返回这两个索引构成的向量
                return {iter->second, i};
            }
            // 否则，将当前数字插入到 map 中，以备后续查找
            map.insert(pair<int, int>(nums[i], i));
        }
        
        // 如果没有找到符合条件的索引对，则返回空向量
        return {};
    }
};

本题其实有四个重点：