代码随想录Day06|哈希表|242.有效的字母异位词、349.两个数组的交集、202.快乐数、1.两数之和

---

代码随想录开源LeetCode题单：代码随想录

---

一、基础知识

当需要快速判断一个元素是否出现在集合中时，可以考虑使用哈希表。

Java中常用的集合有HashMap和HashSet，
HashSet ⽤于存储唯⼀的元素，不允许重复；
HashMap ⽤于存储键值对（key, value），其中每个键key都唯⼀，每个键key关联⼀个值value,键不可重复，值可重复。

二、题目

1.LeetCode242

LeetCode242.有效的字母异位词

1.1 思路

数组做哈希表
题目说两个数组s、t中只有小写字母，故可以定义一个数组record[26]用来上记录字符串里字符出现的次数，字符a到字符z的ASCII码是26个连续的数值，故字符a下标为0，字符z映射为下标25。
字符串的第s[i] - ‘a’ 个所在的元素的ASCII码取值范围为0~25，在遍历字符串s时，将 s[i] - ‘a’ 所在的元素做+1，统计字符串s中26个字符出现的次数。
对t中出现的字符映射哈希表索引上的数值再做-1的操作。
最后，record数组如果有的元素不为0，则不是字母异位词，return false。
如果record数组所有元素都为零0，说明字符串s和t是字母异位词，return true。

1.2 代码

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']++;    //charAt(i)为字符串中下表为i的元素
        }

        for (int i = 0; i < t.length(); i++) {
            record[t.charAt(i) - 'a']--;
        }
        
        for (int count: record) {
            if (count != 0) {   // record数组如果有的元素不为零0，不匹配，不是字母异位词
                return false;
            }
        }
        return true;    // record数组所有元素都为零0，是字母异位词
    }
}

2.LeetCode349

LeetCode349.两个数组的交集

2.1 法一：数组做哈希表

2.1.1 思路

题目指明数组长度范围为[1, 1000]，每个数值大小范围为[1, 1000]，
可以利用数组来定义两个哈希表hash1、hash2，记录每个元素在两个数组中出现的次数。
依次遍历数组nums1、nums2，对于每个元素i，将hash[i]加一。
遍历两个hash，若元素i在hash1和hash2中都大于0，则为交集元素。
将这些元素添加到列表resList中，最后转换为数组。

2.1.2 代码

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int[] hash1 = new int[1000];
        int[] hash2 = new int[1000];
        for(int i : nums1)
            hash1[i]++;
        for(int i : nums2)
            hash2[i]++;
        List<Integer> resList = new ArrayList<>();
        for(int i = 0; i < 1000; i++)
            if(hash1[i] > 0 && hash2[i] > 0)
                resList.add(i);
        int index = 0;
        int res[] = new int[resList.size()];
        for(int i : resList)
            res[index++] = i;
        return res;
    }
}

2.2 法二：直接使用HashSet

2.2.1 思路

与法一思路大体相同，不同的是不需要自己定义数组来存储每个数的出现次数，直接使用集合HashSet并遍历判断即可。

2.2.2 代码

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<>();
        //遍历nums1
        for (int i : nums1) {
            set1.add(i);
        }
        //遍历nums2的过程中判断哈希表中是否存在该元素
        for (int i : nums2) {
            if (set1.contains(i)) {
                resSet.add(i);
            }
        }
      
		return resSet.stream().mapToInt(x -> x).toArray();
		
    }
}

3.LeetCode202

LeetCode202.快乐数

求解本题时，不应该过多的考虑数学上快乐数的算法，应关注题目中的描述的“和可能无限循环”，利用哈希表快速判断当下求的和是否已经在集合中出现过。

3.1 思路

题目中描述求解过程会无限循环，那么也就是说求和的过程中，sum会重复出现！
当要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。
所以这道题目使用哈希法，来判断这个sum是否重复出现，如果重复了就是return false， 否则一直找到sum为1为止。

• 判断sum是否重复出现就可以使用HashSet。
• 对于求和的过程，需要取数值各个位上的单个数进行平方后求和。

3.2 代码

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;
    }
}

4.LeetCode1

LeetCode1.两数之和

4.1 思路

本题既需要取元素的值（判断元素是否被遍历过），又要取元素的下标，可将元素的值与元素的下标视作一组键值对，key存元素值，value存下标，用map储存。
遍历数组，对于数组中的每个元素，去map中查找是否有key值与之匹配（相加为target），若有则匹配，没有则将当前元素存入map中，继续遍历直到循环结束。

4.2 代码

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int[] result = new int[2];

        if(nums == null || nums.length == 0) return result;

        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < nums.length; i++){
            int temp = target - nums[i];
            if(map.containsKey(temp)){
                result[1] = i;
                result[0] = map.get(temp);
                break;     
            }
            map.put(nums[i], i);
        }
        return result;
        
    }
}