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

LeetCode 242 有效的字母异位词

题目链接：https://leetcode.cn/problems/valid-anagram/
视频讲解：https://www.bilibili.com/video/BV1YG411p7BA/

题目描述：给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

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

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

思路：定义一个数组，储存’a’ - 'z’出现的个数，分别遍历两个字符串， s字符串出现某个字符就+1，t字符串出现相同字符就-1；最后看数组所有的值是不是为0，都为0说明s 和 t 互为字母异位词。

class Solution {
    public boolean isAnagram(String s, String t) {
        int[] hash = new int[26];
        for(int i = 0; i < s.length(); i++){
            hash[s.charAt(i) - 'a']++;
        }
        for(int j = 0; j < t.length(); j++){
            hash[t.charAt(j) - 'a']--;
        }
        for(int k = 0; k < 26; k++){
            if(hash[k] != 0){
                return false;
            }
        }
        return true;
    }
}

注：

• s.charAt(i)是用来返回字符串在i位置的值。
• s.charAt - 'a’就会用Ascall计算， 所以hash[xxx]++意思就是在第i个位置加1
• 这里的‘a’必须要用单引号- 当获得字符串的大小的时候要加括号 s.length()

LeetCode 349 两个数组的交集

题目链接：https://leetcode.cn/problems/intersection-of-two-arrays/
视频讲解：https://www.bilibili.com/video/BV1ba411S7wu/

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

思路：该题能使用数组来做哈希的题目，是因为题目都限制了数值的大小。
若这道题目没有限制数值的大小，就无法使用数组来做哈希表了。
而且如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。此时就要使用另一种结构体set了

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        if(nums1 == null || nums1.length == 0 || nums2 == null || nums2.length == 0){
            return new int[0];
        }
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> resSet = new HashSet<>();
        for(int i : nums1){//遍历数组1
            set1.add(i);
        }
        for(int i : nums2){//遍历数组2的过程中判断哈希表中是否存在该元素
            if(set1.contains(i)){
                resSet.add(i);
            }
        }
        return resSet.stream().mapToInt(x -> x).toArray();//将结果几何转为数组
    }
}

注：

• 使用return new int[0]；假设一个方法返回一个数组，如果它返回null，则调用方法必须先判断是否返回null，才能对返回数组进一步处理，而如果返回空数组，则无须null引用检查。鉴于此，返回数组的方法在没有结果时通常返回空数组，而不是null，这样做对于函数调用者的处理比较方便。

• 创建一个hashset需要如下：Set set = new HashSet<>(); 注意大小写

• 将结果集合转为数组： return resSet.stream().mapToInt(x -> x).toArray();

LeetCode 202 快乐数

题目链接：https://leetcode.cn/problems/happy-number/

题目描述：编写一个算法来判断一个数 n 是不是快乐数。
快乐数的定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果这个过程结果为 1，那么这个数就是快乐数。如果 n 是快乐数就返回 true ；不是，则返回 false 。

示例1：输入：n = 19
输出：true
解释：
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1

示例2：输入：n = 2
输出：false

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

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> record = new HashSet<>();
        while(n != 1 && !record.contains(n)){
            record.add(n);
            n = getNextNumber(n);
        }
        return n == 1;
    }
    //获得每个位置上的数字的平方和
    private int getNextNumber(int n){
        int sum = 0;
        while(n > 0){
            int temp = n % 10;
            sum += temp * temp;
            n = n / 10; 
        }
        return sum;
    }
}

LeetCode 1 两数之和

题目链接：https://leetcode.cn/problems/two-sum/
视频讲解：https://www.bilibili.com/video/BV1aT41177mK/

题目描述：给定一个整数数组 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正合适。

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

class Solution {
    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];// 遍历当前元素，并在map中寻找是否有匹配的key
            if(map.containsKey(temp)){
                res[1] = i;
                res[0] = map.get(temp);
                break;
            }
            map.put(nums[i], i);// 如果没找到匹配对，就把访问过的元素和下标加入到map中
        }
        return res;
    }
}