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

242. 有效的字母异位词

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

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

示例 1:

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

示例 2:

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

文章讲解：代码随想录

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

第一印象：第一时间想到的是暴力解法，但是由于基础薄弱，还是看了讲解之后才能想到完整的解法。

看完讲解：暴力解法的思路是将字符串转为字符数组，再将字符数组通过ASCII码排序，如果equals相等，即为异位词，这边暴力解法我用的是力扣官方的题解。哈希映射法是定义一个长度为26的record数组，每个下标对应一个字母，然后通过遍历s和t，分别对record对应下标的元素进行+1和-1的操作，如果record中的元素皆为0，则为异位词。

//  暴力排序法
class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        char[] str1 = s.toCharArray();
        char[] str2 = t.toCharArray();
        Arrays.sort(str1);
        Arrays.sort(str2);
        return Arrays.equals(str1, str2);
    }
}

//  哈希映射法
class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        int[] record = new int[26];
        for (int i = 0; i < s.length(); i++) {
            record[s.charAt(i) - 'a']++;
        }
        for (int i = 0; i < t.length(); i++) {
            record[t.charAt(i) - 'a']--;
        }
        for (int i = 0; i < record.length; i++) {
            if (record[i] != 0) {
                return false;
            }
        }
        return true;
    }
}

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] 也是可通过的

文章讲解：代码随想录

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

第一印象：实话实说，完全不会哈哈。

看完讲解：对于查看一组数据中是否存在某元素，或者元素过于离散，使用set集合。

// Set集合法
import java.util.Set;
import java.util.HashSet;

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) {
            set1.add(i);
        }
        for (int i : nums2) {
            if (set1.contains(i)) {
                ResSet.add(i);
            }
        }
        int j = 0;
        int[] array = new int[ResSet.size()];
        for (int i : ResSet) {
            array[j++] = i;
        }
        return array;
    }
}

// Hash数组法
import java.util.ArrayList;

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int[] hash1 = new int[1005];
        int[] hash2 = new int[1005];
        for (int i : nums1) {          //将元素作为下标，下标不会重复
            hash1[i]++;              
        }
        for (int i :nums2) {
            hash2[i]++;
        }
        List<Integer> resList = new ArrayList<>();
        for (int i = 0; i < 1005; i++) {
            if (hash1[i] > 0 && hash2[i] > 0) {
                resList.add(i);        //这里再将下标添加到ArrayList集合中
            }
        }
        int[] res = new int[resList.size()];
        int j = 0;        //最后要输出的是数组，将ArrayList集合的元素再添加到数组中
        for (int i : resList) {
            res[j++] = i;
        }
        return res;
    }
}

202. 快乐数

编写一个算法来判断一个数 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

文章讲解：代码随想录

第一印象：第一眼在想如何判断。

看完讲解：官方讲解和卡哥的讲解我都看了一边，三种情况，n=1，无限循环，无限大。可以想到无限大是不可能的，因为9会变成81，99会变成162，999会变成243，9999会变成324，他一定会变小而不会一直变大。明白了判断条件，那这道题就变成了，判断是否无限循环，即判断该数是否在且单一数值，这样就是Set集合的强项，一下子明朗了起来。

class Solution {
    private int getSum (int n) {
        int sum = 0;
        while (n > 0) {
            int d = n % 10;
            sum += d * d;
            n /= 10;
        }
        return sum;
    }
    public boolean isHappy(int n) {
        Set<Integer> set = new HashSet<>();
        while (n != 1 && !set.contains(n)) {
            set.add(n);
            n = getSum(n);
        }
        if (n == 1) {
            return true;
        }
        return false;
    }
}

1. 两数之和

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

文章讲解：代码随想录

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

第一印象：看到第一眼，暴力枚举法，其中要注意一些细节，i和j不能相等，所以在初始化j的值的时候应该是i+1。

看完讲解：其实day06的任务下来也觉得应该到HashMap了，所以Map映射应用于要存放两个值的时候，HashMap的基本操作语句还是需要熟练一下，其他没什么，这道题可以多做几次。

//  暴力双for法
class Solution {
    public int[] twoSum(int[] nums, int target) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            for (int j = i+1; j < nums.length; j++) {
                if (nums[i] + nums[j] == target) {
                    return new int[]{i, j};
                }
            }
        }
        return new int[0];
    }
}

//  HashMap法
import java.util.Map;
import java.util.HashMap;

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> hashMap = new HashMap<>();
        int sum = 0;
        int[] res = new int[2];
        for (int i = 0; i < nums.length; i++) {
            sum = target - nums[i];
            if (hashMap.containsKey(sum)) {
                int j = hashMap.get(sum);
                res[0] = i;
                res[1] = j;
                break;
            }
            hashMap.put(nums[i], i);
        }
        return res;
    }
}

今日总结：今天由于是休假，也没有摸鱼，较多的题目一次性写完，实际上收获还是很大的，今天这4道题目分别是数组，Set，Map的应用，过一遍也是对各个操作语句的巩固练习。但是最重要的还是思路，看的出来我对于一道题目的第一印象都是暴力解法（哈哈）。我觉得暴力解法固然没错，但是算法考的就是思维，发散的思维，这种思维是可以练的，就像高中，看到题目里有啥，我就应该想到啥啥啥，我觉得对于算法题目来说，是有共通之处的，方法其实也很简单，我们不都是天才，所以练习就是最好的选择，让自己看到一道题目的时候，脑袋里能想到相关的知识点，从而找到更优解。我希望代码随想录我不是仅限于一刷，二刷三刷都是需要的，以至于工作了之后，也可以反复练习，刷完可以进阶，刷leetcode，总之学无止尽，加油吧。也为同样在刷算法以及偶然看到这篇博客的人加油。