leetcode 哈希表

什么时候用哈希表呢？

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

有效的字母异位词

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

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

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true

示例 2:

输入: s = "rat", t = "car"
输出: false

解题思路：

        用数组来做哈希表，（前提是题目给了数组的范围，在这道题中，数组的size就是26，因为只包含小写字母）可以将两个字符串中字母出现的次数存在哈希表中，哈希表的索引就是他们的ascll码。

涉及知识：

• 数组的创建方法 int [ ] record=new int[26]
• 数组遍历方法：for(int i=0;i<record.length;i++) / for(int i:record)
• 字符串遍历的方法：for(int i=0;i<s.length();i++)
• 获取字符串长度：s.length(),注意这里有括号。获取数组的长度：record.length，这里没有括号。
• String方法charAt（）用来返回指定位置的字符。
• s.charAt(i)-'a'可以返回一个相对于a的ascll码   
• 扩展：想要输出一个字母的ascll码也可以：(int)s.charAt(i)

class Solution {
    public boolean isAnagram(String s, String t) {
        int[] record = new int[26];

        for (int i = 0; i < s.length(); i++) {
            record[s.charAt(i) - 'a']++;     // 并不需要记住字符a的ASCII，只要求出一个相对数值就可以了
        }

        for (int i = 0; i < t.length(); i++) {
            record[t.charAt(i) - 'a']--;
        }
        
        for (int count: record) {
            if (count != 0) {               // record数组如果有的元素不为零0，说明字符串s和t 一定是谁多了字符或者谁少了字符。
                return false;
            }
        }
        return true;                        // record数组所有元素都为零0，说明字符串s和t是字母异位词
    }
}

赎金信 

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。如果可以，返回 true ；否则返回 false 。

magazine 中的每个字符只能在 ransomNote 中使用一次。

解题思路：

和有效的字母异位词相似。但是字母异位词需要考虑两个字符串互相包含。这个只需考虑第一个字符串的内容全都在第二个字符串里就可以了。

涉及知识：

• 创建数组
• 将string中的字符提取出来的方法：1. 将string转成charArray：string.toCharArray()，这样就可以遍历chararray的每一个值了。2. 遍历string的每个字符，下标索引为i，用s.chatAt（i）。

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        if(ransomNote.length()>magazine.length()){
            return false;
        }
        int record[]=new int[26];
        for(int i=0;i<magazine.length();i++){
            record[magazine.charAt(i)-'a']++;//遍历每个string中的每个字符，转成char
        }
        for(char c:ransomNote.toCharArray()){//将string转成char的数组
            record[c-'a']--;
        }
        for(int i:record){
            if(i<0){
                return false;
            }
        }
        return true;

    }
}

 两个数组的交集

给定两个数组 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的使用需要引入两个包：import java.util.HashSet; import java.util.Set;
• 新建一个HashSet的语句：Set <Integer> set1=new HashSet<>()
• set集合添加元素：set.add()
• set集合取元素 set1（i）这种形式是不行的，如果元素是int型，那么用 for（int i：set1）

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> resSet = new HashSet<>();
        //遍历数组1
        for (int i : nums1) {
            set1.add(i);
        }
        //遍历数组2的过程中判断哈希表中是否存在该元素
        for (int i : nums2) {
            if (set1.contains(i)) {
                resSet.add(i);
            }
        }
      
        //方法1：将结果集合转为数组

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

快乐数 

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

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

如果 n 是快乐数就返回 True ；不是，则返回 False 。

示例：

输入：19
输出：true
解释：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1

解题思路：

        验证一个数是不是快乐数，中间可能会经过很多次数字的更新，如果一个数是快乐数，那么单纯的去更新n去判断在多次更新后n是否等于1，是可以的。但是如果这个数不是快乐数，就可能会陷入循环，因此还需要记录之前更新过程中出现的数。而这个记录是不知道数量的，因此需要用到集合。同时HashSet适用于判断一个元素是否在一个集合里的场景。这个在开篇就有提到。

涉及知识：

• 新建一个HashSet的语句：Set<Integer> record=new HashSet<>();
• 集合增加元素：record.add（）
• 将一个数字n每一位都取出来的方法：运用“/”和“%”。“/10”可以获得几个高位，%可以获得最低位，所以要从%开始，先取最低位，再用/取高位

class Solution {
    public boolean isHappy(int n) {
        Set<Integer> record = new HashSet<>();
        while (n != 1 && !record.contains(n)) {
            record.add(n);
            n = getNextNumber(n);
        }
        return n == 1;
    }

    private int getNextNumber(int n) {
        int res = 0;
        while (n > 0) {
            int temp = n % 10;
            res += temp * temp;
            n = n / 10;
        }
        return res;
    }
}

两数之和：

给定一个整数数组 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]

解题思路：

可以这样思考：先遍历nums数组，比如目标target=9，遍历到一个数为2，这时要看这个集合里是否有7。这就又涉及到判断一个集合里是否含有xx元素，这种就要想到 集合！但是hashset只能存储一个值，这道题目既要看下表，又要看值，所以应该用Map。Map的结构是（key，value）用key去索引value。

所以这个题可以构建一个map，去存放已经遍历过的元素的下标和值。然后遍历的过程中去这个map里找是否有那个差值（上文提到的7）。

需要考虑的特殊情况：如果给的数组是空的，那么就要输出null。

涉及知识：

• 创建数组的方法：int [ ] res=new int[n]
• 创建map的方法：Map <Integer，Integer> map=new HashMap<>();
• 获取map中value的方法：map.get(key)
• 判断map中是否存在key： map.contains(key)
• map中存放元素的方法：map.put(key,value)

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++){
        int temp = target - nums[i];   // 遍历当前元素，并在map中寻找是否有匹配的key
        if(map.containsKey(temp)){
            res[1] = i;
            res[0] = map.get(temp);
            break;
        }
        map.put(nums[i], i);    // 如果没找到匹配对，就把访问过的元素和下标加入到map中
    }
    return res;
}