【哈希表part01】| 242.有效的字母异位词、349.两个数组的交集、202.快乐数、1.两数之和

目录

✿LeetCode242.有效的字母异位词❀

✿LeetCode349.两个数组的交集❀

✿LeetCode202.快乐数❀ 

✿LeetCode1.两数之和❀

---

✿LeetCode242.有效的字母异位词❀

链接：242.有效的字母异位词

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

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

 这道题目字符串只包含小写字母，所以可以定义一个长度为26的数组，记录s中字符出现的个数，然后再遍历t,从recore中减去t中出现的字符，最后只需要判断recore是否全为0，代码如下：

public boolean isAnagram(String s, String t) {
        // s 和 t 仅包含小写字母
        char[] record=new char[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;
    }

测试用例：

1. 输入两个字符出现次数相等的字符串
2. 输入两个字符出现次数不相等的字符串
3. 输入的两个字符串其中有一个为空
4. 输入两个空字符串

✿LeetCode349.两个数组的交集❀

链接：349.两个数组的交集

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

 当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。

题目特意说明：输出结果中的每个元素一定是唯一的，也就是说输出的结果的去重的， 同时可以不考虑输出结果的顺序。我们可以用set来解决，代码如下：

public int[] intersection(int[] nums1, int[] nums2) {
        // 1 <= nums1.length, nums2.length <= 1000
        // 0 <= nums1[i], nums2[i] <= 1000
        Set<Integer> set=new HashSet<>();
        Set<Integer> result=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])){
                result.add(nums2[i]);
            }
        }
        int[] arr=new int[result.size()];
        int j=0;
        for(int i:result){
            arr[j++]=i;
        }
        return arr;
    }

 又因为0 <= nums1[i], nums2[i] <= 1000，数据不是很大，我们也可以考虑用数组来解决，代码如下：

public int[] intersection(int[] nums1, int[] nums2) {
        int[] arr=new int[1000];
        Set<Integer> set=new HashSet<>();
        for(int i=0;i<nums1.length;i++){
            arr[nums1[i]]++;
        }
        for(int i=0;i<nums2.length;i++){
            if(arr[nums2[i]]!=0){
                set.add(nums2[i]);
            }
        }
        int[] result=new int[set.size()];
        int j=0;
        for(int i:set){
            result[j++]=i;
        }
        return result;
    }

✿LeetCode202.快乐数❀ 

链接：202.快乐数

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

「快乐数」 定义为：

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

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

 刚看到这道题时，完全没想到用哈希法，还想找一下规律，但是半天却没结果，看了题解之后才发现要用哈希法，这个会无限循环，就是看是否有重复的出现，那么久用set,代码如下：

public boolean isHappy(int n) {
        // 无限循环，判断是否会重复  用set
        int num=0;
        int sum=0;
        Set<Integer> set=new HashSet<>();
        while(sum!=1){
            sum=0;
            while(n!=0){
                num=n%10;
                n=n/10;
                sum+=num*num;
            }
            if(set.contains(sum)){
                return false;
            }
            set.add(sum);
            n=sum;
            
        }
        return true;
        
    }

测试用例：

1. 输入一个快乐数
2. 输入一个非快乐数
3. 输入不合法的数字（如：0）

✿LeetCode1.两数之和❀

链接：1.两数之和

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

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

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

 当需要找一个元素是否在这个集合中出现过时，就想到用哈希法。本题就是找target-nums[i]是否出现在数组中出现，用HashMap，其中key存储的是数值，Value存储的是下标，代码如下：

public int[] twoSum(int[] nums, int target) {
        // 2 <= nums.length <= 104
        // 只会存在一个有效答案
        Map<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<nums.length;i++){
            // 看target-nums[i]是否在map中出现过
            if(map.containsKey(target-nums[i])){
                return new int[]{i,map.get(target-nums[i])};
            }
            map.put(nums[i],i);
        }
        //不存在
        return new int[]{-1,-1};
    }