力扣刷题Day6 | 哈希表Part01：哈希表理论基础，242.有效的字母异位词，349. 两个数组的交集，202. 快乐数，1. 两数之和

weixin_48337768

已于 2024-03-15 13:09:46 修改

阅读量999

点赞数 28

文章标签： leetcode 算法

于 2024-03-12 15:49:25 首次发布

本文链接：https://blog.csdn.net/weixin_48337768/article/details/136636235

版权

day5休息。

哈希表理论基础

文章讲解：https://programmercarl.com/%E5%93%88%E5%B8%8C%E8%A1%A8%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html

哈希表适用场景：给你一个集合，判断这个数/字母有没有在集合中出现过。

哈希法中有三种常见的数据结构：数组，集合set，映射map。
当给定数据大小已知时，数据量较小时，可以使用数组；
当给定数据大小未知或者数据很分散时，用数组就不合适了，就要考虑set或map。

242.有效的字母异位词

题目链接：https://leetcode.cn/problems/valid-anagram/description/

文章讲解/视频讲解： https://programmercarl.com/0242.%E6%9C%89%E6%95%88%E7%9A%84%E5%AD%97%E6%AF%8D%E5%BC%82%E4%BD%8D%E8%AF%8D.html

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

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

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

本题要判断一个字符串中的字母在另一个字符串中是否出现过，符合哈希表的使用场景，因此考虑三种常见的数据结构。由于该题的字符串中可能出现的字母就26个，数量较少，因此可以用数组来做。

写代码的时候出现了一个错误，最后一个循环条件我写成了i < s.size()，这是有问题的，这样循环无法遍历26个字母，因此这里的条件应该是<26，这里告诉我们，写代码的时候要搞清楚每一个循环的作用。

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

        for(i = 0; i < 26; i++) {
            if(record[i] != 0) return false;
        }

        return true;
    }
};

看这题的时候在想，前两个for循环能不能合为一个，不过根据leetcode的测试，应该是不行的，因为题目中并没有说明两个字符串的长度相等。虽然我默认字符串长度不等的时候结果一定是false，但是代码中没有办法排除这种情况。因此这里的两个循环还是得分开写，除非加上对字符串长度的判断，试了一下发现可以通过，代码也不太复杂，如下。

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

            for(i = 0; i < 26; i++) {
            if(record[i] != 0) return false;
            }
        }

        return true;
    }
};

349.两个数组的交集

题目链接：https://leetcode.cn/problems/intersection-of-two-arrays/description/
文章讲解/视频讲解：https://programmercarl.com/0349.%E4%B8%A4%E4%B8%AA%E6%95%B0%E7%BB%84%E7%9A%84%E4%BA%A4%E9%9B%86.html

给定两个数组 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] 也是可通过的

c++中有三种关于set的数据结构，分别是set、multiset和unordered_set。特性对比如下：
在这里插入图片描述

std::set和std::multiset底层实现都是红黑树，std::unordered_set的底层实现是哈希表，使用unordered_set 读写效率最高，并不需要对数据进行排序，而且还不允许数值重复，相当于直接对数据进行了去重的操作，很符合本题的题意，故本题选择unordered_set。

因为之前没学过STL，所以对本题代码很陌生，只能对照答案先学着打出来了。

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 num : nums2) {
            if(nums_set.find(num) != nums_set.end()) { //为true说明哈希表中存在所找数字
                result_set.insert(num);
            }
        }
        return vector<int>(result_set.begin(),result_set.end());
    }
};

202.快乐数

题目链接：https://programmercarl.com/0202.%E5%BF%AB%E4%B9%90%E6%95%B0.html
文章讲解：https://programmercarl.com/0202.%E5%BF%AB%E4%B9%90%E6%95%B0.html

class Solution {
public:
    int getsum(int n) {
        int sum = 0;
        while(n) {
            sum = sum + (n % 10) * (n % 10);
            n = 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()) { //这个sum曾经出现过
                return false;
            }
            else {
                set.insert(sum);
            }
            n = sum;
        }
    }
};

1.两数之和

题目链接：https://leetcode.cn/problems/two-sum/description/
文章讲解/视频讲解：https://programmercarl.com/0001.%E4%B8%A4%E6%95%B0%E4%B9%8B%E5%92%8C.html

给定一个整数数组 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，这时就不能用数组和set了，原因如下：

数组的大小是受限制的，而且如果元素很少，而哈希值太大会造成内存空间的浪费。
set是一个集合，里面放的元素只能是一个key，而两数之和这道题目，不仅要判断y是否存在而且还要记录y的下标位置，因为要返回x 和 y的下标。所以set 也不能用。

因此需要用到map。

需要注意的是，这里的数值是作为key，下标为value。因为map的作用书迅速查找key是否在之前出现过，而这道题需要的是查找某个数值之前是否出现过，所以要用数值来作为key。

今日新学习语法：
unordered_map<int, int> map;
auto iter = map.find(target - nums[i]); // auto自动确定返回值类型
return{iter->second,i}; // return后面可以接大括号
map.insert(pair<int, int> (nums[i], i)); // pair用法

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++) {
            auto iter = map.find(target - nums[i]);
            if(iter != map.end()) {
                return{iter->second,i};
            }
            map.insert(pair<int, int> (nums[i], i));
        }
        return {};
    }
};