力扣刷题day05|242有效的字母异位词、349两个数组的交集、202快乐数、1两数之和

Skyc26

已于 2022-09-26 17:20:45 修改

阅读量162

点赞数

分类专栏： leetcode 文章标签： leetcode 哈希算法散列表

于 2022-09-26 17:18:54 首次发布

本文链接：https://blog.csdn.net/dtc1261/article/details/127057166

版权

leetcode 专栏收录该内容

54 篇文章 0 订阅

订阅专栏

文章目录

242. 有效的字母异位词

力扣题目链接

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

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

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

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

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

思路

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

定义一个大小为26的数组，对应的字符a映射为下标0，相应的字符z映射为下标25，第一个字符串出现的字符映射哈希表索引上的数值加一，第二个字符串出现的字符映射哈希表索引上的数值减一，最后遍历hash表中有不为0的，说明字符串s和t一定是谁多了字符或者谁少了字符。

难点

在遍历字符串时，对应映射在hash表中的位置是相对字符’a’的位置，就是s[i] - ‘a’，并不需要记住字符a的ASCII。

public boolean isAnagram(String s, String t) {
    // 定义哈希数组存储每个字母出现的个数
    int[] hash = new int[26];
    // s字符串字母出现一次就+1
    for (int i = 0; i < s.length(); i++) {
        hash[s.charAt(i) - 'a']++;
    }
    // t字符串字母出现一次就-1
    for (int i = 0; i < t.length(); i++) {
        hash[t.charAt(i) - 'a']--;
    }
    // 查看哈希表中是否有不为零的字母
    for (int count: hash) {
        if (count != 0) {
            return false;
        }
    }
    return true;
}

时间复杂度为O(n)
空间复杂度为O(1)

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出现的数字存在hash表，再一个个判断nums2里的数字是否在nums1中出现过，最后返回

难点

如果题目没有限制数值的大小，就无法使用数组来做哈希表。

而且如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。
为什么不直接定义数组存储最终要返回的数字
- 数组要先定义大小，不知道最后会有几个数字出现
- 用hashset可以给结果集去重。若数组2中有两个及以上的相同的数字出现在1中，也不会让结果集中出现两次重复的数字

public int[] intersection(int[] nums1, int[] nums2) {
    // 定义一个hash表存储在nums1中出现的元素
    HashSet<Integer> hs = new HashSet<Integer>();
    // 定义返回用的hashset
    HashSet<Integer> resHs = new HashSet<Integer>();

    // 遍历数组1
    for (int i : nums1) {
        hs.add(i);
    }
    // 遍历数组2
    for (int i : nums2){
        // 如果nums中出现的也在nums中出现了
        if (hs.contains(i)){
            resHs.add(i);
        }
    }

    return resHs.stream().mapToInt(x -> x).toArray();
}

说明：直接使用set 不仅占用空间比数组大，而且速度要比数组慢，set把数值映射到key上都要做hash计算的。不要小瞧这个耗时，在数据量大的情况，差距是很明显的。

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

思路

什么时候会返回false？就是会永远循环，始终变不到1的时候。

那么怎么判断他是否能变到1呢？就是这次求的和已经在之前求过相同的和了

当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法了，所以这道题目使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false，否则一直找到sum为1为止。

难点

取出个位数为%10，取出十位数与个位数%100，如何分别取出每位数？

每次除以10然后模10，就获得每位数

怎么判断是否取完了每一位数字？

最后n如果是一位数n/10即为0，那么判断条件就是while(n != 0)

class Solution {
    public boolean isHappy(int n) {
        // hashset存储出现过的和
        HashSet<Integer> hs = new HashSet<>();
        // 判断现在的和是否是1，是1就是开心数
        while (numSum(n) != 1){
            // 如果现在的和不为1，且hashset里面没有，就把n放进去
            if (!hs.contains(n)) {
                hs.add(n);
                n = numSum(n);
            }else {
                // 如果hashset里面出现过那就不是开心数
                return false;
            }
        }
        return true;


    }
    public int numSum(int n) {
        // 定义每一轮的求和
        int sum = 0;
        while(n != 0) {
            sum += (n % 10) * (n % 10);
            n /= 10;
        }
        return 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）的元素出现在集合里过，所以需要用到哈希表

哈希表为什么用map

我们不仅要知道元素有没有遍历过，还有知道这个元素对应的下标，hashset是一个集合，里面放的元素只能是一个key

本题map是用来存什么的

存遍历过的元素和下标

map中的key和value用来存什么的

key来存元素，value来存下标

public int[] twoSum(int[] nums, int target){
    // 定义hashmap存放遍历过的元素
    HashMap<Integer, Integer> hm = new HashMap<>();
    // 定义返回下表的数组
    int[] res = new int[2];

    // 遍历元素
    for(int i = 0; i < nums.length; i++) {
        // 如果相加和为target的元素在map里存在，就返回下标
        if (hm.containsKey(target-nums[i])){
            res[0] = i;
            res[1] = hm.get(target-nums[i]);
        }
        hm.put(nums[i], i);

    }
    return res;
}