day6 242.有效的字母异位词 、349. 两个数组的交集 、202. 快乐数、 1. 两数之和

一、哈希表

哈希表用来快速判断一个元素是否出现在集合中。

Java中常见的集合有：List、Map、Set、Queue。

二、Leetcode刷题

242.有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
示例 1: 输入: s = “anagram”, t = “nagaram” 输出: true
示例 2: 输入: s = “rat”, t = “car” 输出: false

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

代码如下：这道题我是使用hashmap来做的，可以使用ArrayList来做。

class Solution {
    public boolean isAnagram(String s, String t) {
        if (s.length() != t.length()) return false;
        Map<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < s.length(); i++){
            char ch = s.charAt(i);
            map.put(ch, map.getOrDefault(ch, 0) + 1);
        }
        for (int i = 0; i < t.length(); i++){
            char ch = t.charAt(i);
            map.put(ch, map.getOrDefault(ch, 0) - 1);
            if (map.get(ch) < 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] 也是可通过的

代码如下：这道题我使用的是hashset来做的，首先将两个数组转为set集合去重，然后去遍历短的集合，判读另一个集合contains哪些个值。

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
       Set<Integer> set1 = new HashSet<>();
       Set<Integer> set2 = new HashSet<>();
       for (int num : nums1){
           set1.add(num);
       }
       for (int num : nums2){
           set2.add(num);
       }
       return getIntersection(set1, set2);
    }
    public int[] getIntersection(Set<Integer> set1, Set<Integer> set2){
        if (set1.size() > set2.size()){
            return getIntersection(set2, set1);
        }
        Set<Integer> hashSet = new HashSet<>(set1.size() + 1);
        for (int num : set1){
            if (set2.contains(num)){
                hashSet.add(num);
            }
        }
        int[] intersection = new int[hashSet.size()];
        int index = 0;
        for (int num : hashSet){
            intersection[index++] = num;
        }
        return intersection;
    }
}

202. 快乐数

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

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

代码如下：重点！！！判断sum是否已经出现过；

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

    public int getSum(int n){
        int sum = 0;
        while (n != 0){
            sum += (n % 10) * (n % 10); //个位数
            n = 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]

代码如下：这个使用haspmap来做，key为nums中的元素，value为数组下标。

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

总结

今天做题做的不是很好。集合掌握的不是很好。