【LeetCode+JavaGuide打卡】Day06| 242.有效的字母异位词、349. 两个数组的交集、202. 快乐数、1. 两数之和

最新推荐文章于 2024-11-10 14:06:08 发布

WhoAmI\

最新推荐文章于 2024-11-10 14:06:08 发布

阅读量391

点赞数 9

文章标签： leetcode 哈希算法算法

本文链接：https://blog.csdn.net/qq_56832705/article/details/135907290

版权

学习目标：

242.有效的字母异位词
349. 两个数组的交集
202. 快乐数
1. 两数之和
Java基础常见面试题总结(下)

学习内容：

242.有效的字母异位词

题目链接 &&文章讲解
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 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 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;
    }
}

349. 两个数组的交集

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

HashSet

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        HashSet<Integer> set = new HashSet<>();
        HashSet<Integer> res = new HashSet<>();
        for (int i = 0; i < nums1.length; i++){
            set.add(nums1[i]);
        }

        for (int i = 0; i < nums2.length; i++){
            if (set.contains(nums2[i])) {
                res.add(nums2[i]);
            }
        }
        //方法1：将结果集合转为数组
        return res.stream().mapToInt(x -> x).toArray();


        //方法2：另外申请一个数组存放setRes中的元素,最后返回数组
        int[] arr = new int[res.size()];
        int j = 0;
        for(int i : res){
            arr[j++] = i;
        }
        
        return arr;
    }
 
}

Hash数组

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int[] set = new int[1001];
        List<Integer> res = new ArrayList<>();
        for (int i : nums1){
            set[i] = 1;
        }

        for (int i : nums2){
            if (set[i] == 1) {
                res.add(i);
                set[i]--;
            }
        }
        
        int index = 0;
        int result[] = new int[res.size()];
        for(int i : res)
            result[index++] = i;
        return result;
    }
 
}

202.快乐数

题目链接&&文章讲解

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

「快乐数」定义为：

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

使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false，否则一直找到sum为1为止。
判断sum是否重复出现就可以使用HashSet

HashSet

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

    public int getSum(int n){
        int sum = 0;
        while(n != 0){
            int t = n % 10;
            sum = sum + t * t;
            n = n / 10;
        }
        return sum;
    }
}

1. 两数之和

题目链接&&文章讲解

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

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

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

为什么会想到用哈希表
本题需要一个集合来存放遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，也就是是否出现在这个集合。
哈希表为什么用map
不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，map中的存储结构为 {key：数据元素，value：数组元素对应的下标}

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