哈希表法解题思路一（附有leetcode有效的字母异位词，两个数组的交集，快乐数，两数之和真题）

今天学习了哈希表理论基础，总结得出：当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。

当时用哈希法时，我们有三种选择，数组，set，，map；那么我们应该如何选择所使用的哈希表呢？

概括而言，当题目限制数值大小及范围时，使用数组来做；当数值大小范围无限制时，使用set来做；当数值为键值对时，使用map来做。但这也是经验概括，具体题目还是需要具体分析，但这样现目前根据题目数值设定判断，可以快捷一些。

那么接下来我们就来解几道leetcode中较为经典的使用哈希法解题的题目，涵括了使用数组，set，map三种方法。

话不多说，上题！

242. 有效的字母异位词

题目描述：

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

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

示例 1:

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

输出: true

示例 2:

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

输出: false

提示:

• 1 <= s.length, t.length <= 5 * 104

• s 和 t 仅包含小写字母

解题思路及心得：

我们除开两层for循环的暴力解法，来思考一下更优的方法。 这道题简单说来，其实就是判断两个字符串中的字母是否相同，位置可以不同。其实本质也就是判断元素是否包含在集合里的问题，那么我们就可以采用哈希法。 因为字符串中仅包含小写字母，小写字母只有26个，范围可控且数量较小，那么我们就可以采用数组来记录每个字符串中字母出现的个数。数组其实就是一个简单哈希表。 那么我只需要定义一个大小为26的数组，并且初始化为0即可，因为字符a到z的ASCII码值也是连续的26个数值。 那么我们来理清思路：

1. 我们首先定义一个叫做record的数组来记录字符串s里字符出现的次数，我们需要把字符映射到数组（哈希表）的索引下标上，上面提到了因为字符a到z的ASCII码是连续的26个数值，所以字符a的下标映射为0，字符z的下标映射为25。

2. 那么我们在遍历s字符串时，无需记忆每个字符的具体ASCII数值，只需得到一个相对的差值即可，即将s[i]-'a'所在的元素加一，那么这样就可以将s字符串中每个字符出现的次数记录下来了。

3. 接下来我们就检查t字符串中是否出现了这些字符，我们依旧使用相同的方法，只不过在便利时，对t中出现的字符映射到哈希索引上的值-1即可。

4. 最后我们判断一下数组record的每个元素值是否都为0，如果有任何一个不为0，那么说明两个字符串中这个字符的数量不同，那么返回false；如果都为0，说明它们互为字母异位词，返回true。

代码如下：

class Solution {
    public boolean isAnagram(String s, String t) {
        //初始化一个新数组用来存放字符串中出现的字母频率，默认赋值都为零
        int[] record = new int[26];
        //遍历s字符串，得到每个字母出现的次数
        for(int i = 0;i < s.length();i++){
            record[s.charAt(i) - 'a']++;//并不需要记住每个字母的ASCII,只要求出一个相对数值即可
        }

        //遍历t字符串，得到相对于s字符串每个字母出现的频率差值\
        for(int i = 0;i < t.length();i++){
            record[t.charAt(i) - 'a']--;
        }
        //判断最后record数组的每个值是否为0.如果有任何一个元素不为0.这说明两字符串不互为字母异位词
        for(int i = 0;i < 26;i++){
            if(record[i] != 0){
                return false;
            }
        }
        return true;

    }
}

349. 两个数组的交集

题目描述：

给定两个数组 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] 也是可通过的

提示：

• 1 <= nums1.length, nums2.length <= 1000

• 0 <= nums1[i], nums2[i] <= 1000

解题思路及心得：

这道题本来是一道很好的使用set来解决的问题，但后来leetcode修改了他的范围，变成了有限制的，那么使用数组也可以解出来，并且更节省时间，但我们这道题依旧采用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);
            }
        }
        //将结果几何转换为数组
        return resSet.stream().mapToInt(x -> x).toArray();
    }
}

202. 快乐数

题目描述：

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

「快乐数」 定义为：

• 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。

• 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。

• 如果这个过程 结果为 1，那么这个数就是快乐数。

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

示例 1：

输入：n = 19

输出：true

解释：

12 + 92 = 82

82 + 22 = 68

62 + 82 = 100

12 + 02 + 02 = 1

示例 2：

输入：n = 2

输出：false

提示：

• 1 <= n <= 231 - 1

解题思路及心得：

这道题依旧是使用set解题的。

那么我们来分析一下题目，题目中说了，可能会出现无限循环，那么也就是说，在求和过程中，所求得的和会重复出现。那么即是判断一个数字是否在集合中出现的问题，我们就使用哈希法。

那么如果一个和重复出现了，就说明陷入到了无限循环的问题中，那么也就说明这个数不是快乐数，返回false，否则就一直找到变为1为止。

判断和是否重复出现，我们就可以使用unordered_set。

另外我们还要注意一个难点，即对一个数字的每一位进行平方求和，如果这个过程搞不清楚的话，就无法解出这道题了。

代码如下：

class Solution {
    public boolean isHappy(int n) {
        //定义一个哈希表用来存放每次得到的sum
        Set<Integer> record = new HashSet<>();
        //n既不等于1又未在map中出现过时，继续循环求和过程，直到变成1或出现重复
        while(n != 1 && !record.contains(n)){
            record.add(n);
            n = getNextNumber(n);
        }
        //判断此时n是否等于1，如果为1，返回true，否则返回false；
        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;
    }
}

1. 两数之和

题目描述：

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

提示：

• 2 <= nums.length <= 104

• -109 <= nums[i] <= 109

• -109 <= target <= 109

• 只会存在一个有效答案

做题思路及心得：

这道题中我们采用的是map

为什么使用map呢，我们首先来理一下思路，首先这道题要在数组中找两个和等于target的元素的下标，那么也就是需要查找数值是否出现在集合里，所以一定想到采用哈希法，那为什么使用map来解题呢，这道题不仅涉及到了数组中元素的值，还涉及到了下标，那么一个元素的数值和其下标即为一对键值对，那么用到了键值对，我们就需要使用map来解决。

那么如何来找出匹配的元素呢，我们可以先定义一个map来存放已经遍历过得元素值及下标，然后循环遍历数组，查看每个元素的另一个匹配值是否被遍历过。也就是在map中查找是否存在这个匹配元素，如果存在，则返回正在遍历的下标和匹配元素的下标，如果不存在，就将当前遍历的元素存入map。

思路有了，我们来编写代码：

class Solution {
    public int[] twoSum(int[] nums, int target) {
        //定义一个大小为2的数组用来存放返回结果
        int[] res = new int[2];
        if(nums == null || nums.length == 0){
            return res;
        }
        //定义一个map用来存放遍历过得元素数值及下标
        Map<Integer,Integer> map = new HashMap<>();
        for(int i = 0;i < nums.length;i++){
            //遍历当前元素，并在map中查找是否有匹配的key
            int temp = target - nums[i];
            if(map.containsKey(temp)){
                //找到匹配的key，则将key和正在遍历的元素下标存入数组res，并跳出循环
                res[1] = i;
                res[0] = map.get(temp);
                break;
            }
            //未找到匹配的key，则将遍历过得元素值及下标存入map
            map.put(nums[i],i);
        }
        return res;
    }
}

以上就是今天的分享，希望对大家有所帮助。