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

太过爱你忘了你带给我的痛 2024-04-23 03:54 2阅读 0赞

#### 哈希表理论基础 ####

1、哈希表定义：

哈希表是根据关键码的值而直接进行访问的数据结构。

这么这官方的解释可能有点懵，其实直白来讲其实数组就是一张哈希表。

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

![e26ce99f42b9093bf6ddb16833b88766.png][]

2、那么哈希表能解决什么问题呢，**一般哈希表都是用来快速判断一个元素是否出现集合里。**

例如要查询一个名字是否在这所学校里。

要枚举的话时间复杂度是O(n)，但如果使用哈希表的话， 只需要O(1)就可以做到。

我们只需要初始化把这所学校里学生的名字都存在哈希表里，在查询的时候通过索引直接就可以知道这位同学在不在这所学校里了。

将学生姓名映射到哈希表上就涉及到了**hash function ，也就是哈希函数**。

3、常见的三种哈希结构

当我们想使用哈希法来解决问题的时候，我们一般会选择如下三种数据结构。

*  数组
 *  set （集合）
 *  map(映射)

4、总结：

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

但是哈希法也是**牺牲了空间换取了时间**，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。

如果在做面试题目的时候遇到需要判断一个元素是否出现过的场景也应该第一时间想到哈希法！

#### 242.有效的字母异位词 ####

1、题目链接：[代码随想录][Link 1]

2、文章讲解：[代码随想录][Link 1]

3、视频讲解： [学透哈希表，数组使用有技巧！Leetcode：242.有效的字母异位词\_哔哩哔哩\_bilibili][Leetcode_242._bilibili]

4、题目：

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

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

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

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

5、思路：

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

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

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

那看一下如何检查字符串t中是否出现了这些字符，同样在遍历字符串t的时候，对t中出现的字符映射哈希表索引上的数值再做-1的操作。

那么最后检查一下，**record数组如果有的元素不为零0，说明字符串s和t一定是谁多了字符或者谁少了字符，return false。**

最后如果record数组所有元素都为零0，说明字符串s和t是字母异位词，return true。

##### 字典解法 #####

*  时间复杂度：O(m+n)
 *  空间复杂度：O(1)

class Solution {
        public boolean isAnagram(String s, String t) {
            int[] res = new int[26];
            // 统计s中每个字母出现的次数
            for (int i = 0; i < s.length(); i++) {
                // s.charAt(i) - 'a' 是为了将字母转化为0-25的整数
                res[s.charAt(i) - 'a']++;
            }
            // 统计t中每个字母出现的次数
            for (int i = 0; i < t.length(); i++) {
                res[t.charAt(i) - 'a']--;
            }
            // 数组如果有不为0的元素，说明两个字符串中字母的个数不相等，返回false
            for (int i = 0; i < 26; i++) {
                if (res[i] != 0) {
                    return false;
                }
            }
            // 数组中没有不为0的元素，说明两个字符串中字母的个数相等，返回true
            return true;
        }
    }

#### 349. 两个数组的交集 ####

1、题目链接：[代码随想录][Link 2]

2、文章讲解：[代码随想录][Link 2]

3、视频讲解：[学透哈希表，set使用有技巧！Leetcode：349. 两个数组的交集\_哔哩哔哩\_bilibili][set_Leetcode_349. _bilibili]

4、题目：

给定两个数组，编写一个函数来计算它们的交集。

![9701d9c08e1e5cb349f0fe140825e668.png][]

**说明：** 输出结果中的每个元素一定是唯一的。 我们可以不考虑输出结果的顺序。

*  时间复杂度: O(m+n)
 *  空间复杂度: O(n)

class Solution {
        // 用两个set来处理
        public int[] intersection(int[] nums1, int[] nums2) {
            if (nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0) {
                return new int[0];
            }
            // 存放数组1的元素
            Set<Integer> set1 = new HashSet<>();
            // 存放最终结果的元素
            Set<Integer> set2 = new HashSet<>();
            // 遍历数组1
            for (int i : nums1) {
                set1.add(i);
            }
            // 遍历数组2
            for (int i : nums2) {
                // 如果数组1存在该元素
                if (set1.contains(i)) {
                    set2.add(i);
                }
            }
            // 将set2转换为数组
            return set2.stream().mapToInt(Integer::intValue).toArray();
        }
    }

#### 202、快乐数 ####

1、题目链接：[代码随想录][Link 3]

2、文章讲解：[代码随想录][Link 3]

3、题目：

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

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

如果 n 是快乐数就返回 True ；不是，则返回 False 。

**示例：**

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

4、思路：

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

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

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

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

判断sum是否重复出现就可以使用unordered\_set。

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

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

class Solution {
        public boolean isHappy(int n) {
            Set<Integer> set = new HashSet<>();
            while (n != 1 && !set.contains(n)) {
                // 将n添加到set中
                set.add(n);
                // 计算n的和方程
                n = sumOfSquare(n);
            }
            return n == 1;
        }
    
        // 求和方程
        private int sumOfSquare(int n) {
            int sum = 0;
            // 求和方程
            while (n > 0) {
                // 计算n的个位数的平方
                sum += (n % 10) * (n % 10);
                // 将n除以10
                n /= 10;
            }
            return sum;
        }
    }

#### 1、两数之和 ####

1、题目链接：[代码随想录][Link 4]

2、文章讲解：[代码随想录][Link 4]

3、视频讲解：

[梦开始的地方，Leetcode：1.两数之和，学透哈希表，map使用有技巧！\_哔哩哔哩\_bilibili][Leetcode_1._map_bilibili]

4、题目：

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

**示例:**

给定 nums = \[2, 7, 11, 15\], target = 9

因为 nums\[0\] + nums\[1\] = 2 + 7 = 9

所以返回 \[0, 1\]

5、思路：

首先我再强调一下 **什么时候使用哈希法**，当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。

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

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

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

再来看一下使用数组和set来做哈希法的局限。

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

此时就要选择另一种数据结构：map ，map是一种key value的存储结构，可以用key保存数值，用value再保存数值所在的下标。

接下来需要明确两点：

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

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

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

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

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

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

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

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

class Solution {
        // 和167题区别是：167已经排好序，从1开始，所以可以左右指针
        public int[] twoSum(int[] nums, int target) {
            int[] res = new int[2];
            if (nums == null || nums.length == 0) {
                return res;
            }
            Map<Integer, Integer> map = new HashMap<>();
            for (int i = 0; i < nums.length; i++) {
                int temp = target - nums[i];
                if (map.containsKey(temp)) {
                    res[0] = map.get(temp);
                    res[1] = i;
                    break;
                }
                // 数组的值作为key，下标作为value
                map.put(nums[i], i);
            }
            return res;
        }
    }

[e26ce99f42b9093bf6ddb16833b88766.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/5cfc65f4a0224c4d90b653b87d0c94f8.png
[Link 1]: https://www.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#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
[Leetcode_242._bilibili]: https://www.bilibili.com/video/BV1YG411p7BA
[Link 2]: https://www.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#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
[set_Leetcode_349. _bilibili]: https://www.bilibili.com/video/BV1ba411S7wu
[9701d9c08e1e5cb349f0fe140825e668.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/287d73bfa9304b8f95be51c78828e9ea.png
[Link 3]: https://www.programmercarl.com/0202.%E5%BF%AB%E4%B9%90%E6%95%B0.html#%E6%80%9D%E8%B7%AF
[opens new window]: 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
[Link 4]: https://www.programmercarl.com/0001.%E4%B8%A4%E6%95%B0%E4%B9%8B%E5%92%8C.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
[Leetcode_1._map_bilibili]: https://www.bilibili.com/video/BV1aT41177mK