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

 1 242. 有效的字母异位词

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

提示:

• 1 <= s.length, t.length <= 5 * 104
• s 和 t 仅包含小写字母

思路：

        基础思路：本题考查了两个点，首先两个集合中元素是否一致，其次元素个数是否一致。因此，将字符串 s 生成集合 set，逐个遍历字符串 t 中元素并判断。涉及元素是否在集合中，就要想到使用哈希表。另字符串长度有限，考虑使用数组实现较为合适。

        进阶思路：字符串仅包含26个小写字母，利用数组下标区分不同字母，数组数值记录元素出现次数，遍历 s 时累加，遍历 t 时递减，最终遍历字母数组，若均为 0 ，则证明两个字符串为字母异位词，反之不是。

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

Java实现

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 i = 0;i<t.length();i++)
            hash[t.charAt(i)-'a']--;
        for(int i = 0;i<26;i++){
            if(hash[i]!=0)
                return false;
        }
        return true;
    }
}

2 349. 两个数组的交集

题目： 给定两个数组 nums1 和 nums2 ，返回它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。

提示：

• 1 <= nums1.length, nums2.length <= 1000
• 0 <= nums1[i], nums2[i] <= 1000

思路：本题考查数组交集，即两个集合中重复的元素，立刻想到使用哈希表。要求输出结果元素唯一，考虑使用 unorderset 的底层结构来构造哈希表，重复元素只保留一个。本题数组长度有限，可考虑使用数组实现，也可直接使用 set 实现。遍历 nums1 生成元素集合 set，再遍历 nums2 查看各元素是否在 set 中，如果存在保存到辅助数组 res 中。

注意：set 和 res 均为 unorderset 实现的 hashset；使用数组实现时，数组长度大于1000即可。

Java实现

import java.util.HashSet;
import java.util.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> result = new HashSet<>();

        // // 遍历数组1，生成哈希表
        // for(int i : nums1){
        //     set1.add(i);
        // }

        // // 遍历数组2，在哈希表中查询是否存在相同元素
        // for(int i : nums2){
        //     if(set1.contains(i)){
        //         result.add(i);
        //     }
        // }
        
        // // 将结果哈希表转化为数组输出
        // int[] res = new int[result.size()];
        // int j= 0;
        // for(int i : result){
        //     res[j++] = i;
        // }
        // return res;

        int[] hash1 = new int[1001];
        Set<Integer> result = new HashSet<>();
        for(int i :nums1)
            hash1[i]++;
        for(int i : nums2){
            if(hash1[i]!= 0)
                result.add(i);
        }
        int[] res = new int[result.size()];
        int j= 0;
        for(int i : result){
            res[j++] = i;
        }
        return res;

        
    }
}

3 202. 快乐数

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

  「快乐数」 定义为：

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

    如果 n 是 快乐数 就返回 true ；不是，则返回 false 。

提示：

• 1 <= n <= 231 - 1

思路：本题考查两个点，首先整数各位上数组的平方和是否为 1，其次是否无限循环不结束。

解决平方和为 1 的问题，使用一个循环对 10 取余后除以 10，循环结束后判断累加结果是否为 1。判断是否无限循环的问题，若每轮循环结束后的 sum 值都未出现，则一直运行，若出现重复元素，则说明是无限循环的，这里使用 set 来判断。

注意：使用 unorderset 实现的hashset，避免重复元素。

Java实现

import java.util.HashSet;
import java.util.Set;

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> sumSite = new HashSet<>();
        // 测试用例通过2/3，有问题但是没发现
        // int sum = 0;
        // int start = n;
        // while(sum != 1){
        //     while(start!=0){
        //         sum += ((start%10)*(start%10));
        //         start = start/10;
        //     }
        //     start = sum;
        //     if(sumSite.contains(sum)){
        //         return false;
        //     }
        //     else{
        //         sumSite.add(sum);
        //         sum = 0;
        //     }
        // }
        // return true;
        
        int sum, digit;
        while(n!=1 && !sumSite.contains(n)){
            sumSite.add(n);
            sum = 0 ;
            while(n!=0){
                digit = n % 10;
                sum += digit * digit;
                n /= 10;
            }
            n = sum;
        }
        return n == 1;
    }
}

4 1. 两数之和

题目：给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。

提示：

• 2 <= nums.length <= 104
• -109 <= nums[i] <= 109
• -109 <= target <= 109
• 只会存在一个有效答案

思路：遍历数组 nums 并生成哈希表，判断与当前元素和为 target 的元素是否已经在集合中。其次，需要记录符合条件元素的下标，此时考虑使用 map，不仅记录 Key 值，还保存元素 Value。

注意：map 中 key 值查找方便便于比对，因此将数组值设为 key，数组下标保存到 value 中，当找到符合的元素时再取出。

Java实现

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++){
            // 遍历当前元素，判断在map中是否存在何为target的元素
            int temp = target - nums[i];
            if(map.containsKey(temp)){
                res[0] = i;
                res[1] = map.get(temp);
                break;
            }
            map.put(nums[i],i);
        }
        return res;

    }
}