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

题目：

242. 有效的字母异位词 - 力扣（LeetCode）

349. 两个数组的交集 - 力扣（LeetCode）

202. 快乐数 - 力扣（LeetCode）

1. 两数之和 - 力扣（LeetCode）

参考：代码随想录 (programmercarl.com)

需要基础：hash表（也可以叫做散列表），通俗理解呢就是创建一片空间，根据一个分类规律(一般有hash函数)，将我们需要处理的资源映射到这片空间上去，这片空间就叫hash表。

一般哈希表都是用来快速判断一个元素是否出现集合里！！！

（这点很重要，在数组算法题的时候，我们要对这个数组的值进行判断(判断他的值出现了几次、判断他的值是否在其他数组或其本身数组里出现)，都可以使用hash方法）

hash方法有几种：

引自：代码随想录 (programmercarl.com) 

一、有效的字母异位词

要点：

        题目的要求是要判断字符串 t 是否是 字符串s 的字母异位词（什么是字母异位词不重要，他是快速判断一个值(字符串t的每个char）是否出现 在集合(字符串s的每个char)里,这就可以用hash方法）

        核心：1.遍历字符串t统计他的值出现了几次，将值(记为Key)映射到数组a中(是数组a的地址)，其Value是他出现的次数（也是数组a的值）。2.遍历字符串s,在数组a中减去他每个值的数量

感觉这个有点像排序中的快速排序

class Solution {
    public boolean isAnagram(String s, String t) {
        if(s.length() != t.length())
            return false;
        char[] str1 = s.toCharArray();
        char[] str2 = t.toCharArray();  
        int[] a = new int[26];
        int i = 0;
        for(i = 0; i < s.length();i++){
            a[str1[i] - 'a']++;
        }
        for(i = 0;i < t.length();i++){
            a[str2[i] - 'a']--;
            if(a[str2[i] - 'a'] < 0)
                return false;
        }
        return true;
    }
}

 二、两个数组的交集

要点：也是判断一个数组中的值是否在另一个数组出现过；因为要去重，所以选用了容器set,没有数组。

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        if(nums1 == null || nums2 == null || nums1.length == 0 || nums2.length == 0)
            return new int[0];
        Set<Integer> set = new HashSet<>();
        //因为要去重
        Set<Integer> set2 = new HashSet<>();
        for(int i : nums1){
            set.add(i);
        }
        for (int i : nums2){
            if(set.contains(i))
                set2.add(i);            
        }

        int[] result = new int[set2.size()];
        int j = 0;
        for(int i : set2)
            result[j++] = i;
        return result;
    }
}

三、快乐数

要点：也可以用hash方法，核心是判断他每次循环产生的sum是否在之前出现过(统计所有过去出现的集合)

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> set = new HashSet<>();
        while(true){
            int sum = getSum(n);
            if(sum == 1)
                return true;

            if(set.contains(sum))
                return false;
            else 
                set.add(sum);
            n = sum;
        }    
    }

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

四、  两数之和

要点：也是一样的，判断他的另一半(将其加起来等于target)是否在数组前面出现过

class Solution {
    public int[] twoSum(int[] nums, int target) {
        //key is numb,value is index
        Map<Integer, Integer> map = new HashMap<>();
        int[] result = new int[2];
        
        for(int i = 0; i < nums.length;i++){
            if(map.containsKey(target - nums[i])){
                result[0] = map.get(target - nums[i]);
                result[1] = i; 
                break;
            } else {
                map.put(nums[i], i);
            }
        }
        return result;
    }
}