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

本文链接：https://blog.youkuaiyun.com/Danny_8/article/details/138817871

哈希表理论基础

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

文章讲解：https://programmercarl.com/%E5%93%88%E5%B8%8C%E8%A1%A8%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html#%E5%93%88%E5%B8%8C%E5%87%BD%E6%95%B0

在Java中，当想使用哈希法来解决问题时，通常可以选择以下的数据结构：

HashMap：
- HashMap 是Java集合框架中的一个类，它实现了Map接口。
- 它使用哈希表来存储键值对。
- 允许null键和null值（只有一个null键）。
- 不是线程安全的，但可以通过Collections.synchronizedMap()或ConcurrentHashMap来同步。
- 迭代顺序可能与插入顺序不同。
Hashtable：
- Hashtable 是Java集合框架中的另一个类，也是Map接口的实现。
- 与HashMap类似，但它是线程安全的。
- 不允许null键和null值。
- 由于线程同步的开销，其性能通常低于HashMap。
LinkedHashMap：
- LinkedHashMap 是HashMap的子类，它维护了一个双向链表来记录插入顺序或访问顺序。
- 因此，它可以按插入顺序或访问顺序（最近最少使用）迭代键值对。
- 它也允许null键和null值。
ConcurrentHashMap：
- ConcurrentHashMap 是线程安全的HashMap。
- 它使用分段锁（在Java 8之前）或CAS（Compare-and-Swap）和同步控制（在Java 8及之后）来确保在并发环境中高效且线程安全地操作。
- 它提供了与HashMap相似的性能，但在多线程环境中表现更好。
HashSet：
- HashSet 是Java集合框架中的一个类，它实现了Set接口。
- 它基于HashMap实现，并使用哈希表来存储元素。
- 不允许重复元素，但允许null值。
- 不是线程安全的。
LinkedHashSet：
- LinkedHashSet 是HashSet的子类，它使用双向链表来维护元素的插入顺序。
- 因此，在迭代时，它会按照元素的插入顺序返回元素。
- 也不允许重复元素，但允许null值。
TreeMap 和 TreeSet：
- 虽然它们不是基于哈希的，但它们是Java中常用的基于树的数据结构。
- TreeMap 和 TreeSet 使用红黑树来存储元素，并提供了自然排序或自定义排序的功能。
- 它们在查找、插入和删除操作方面提供了平均时间复杂度为O(log n)的性能。

242.有效的字母异位词

题目链接：https://leetcode.cn/problems/valid-anagram/
文档讲解：https://programmercarl.com/0242.%E6%9C%89%E6%95%88%E7%9A%84%E5%AD%97%E6%AF%8D%E5%BC%82%E4%BD%8D%E8%AF%8D.html
视频讲解：https://www.bilibili.com/video/BV1YG411p7BA

思路

由于本题只有小写，可以使用数组来实现简化的哈希表。下标是字母的编号，由ASCII的相对值得到，存储的值是字母出现过的次数。如果出现的次数都相等，则是异位词。
在代码实现的时候，是第一个单词加次数，第二个单词减次数，如果最后数组中所有元素都为0，则为异位词。这样只需要创建一个数组来判断。

代码

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']++;  
        }
        for (int i = 0; i < t.length(); i++) {
            record[t.charAt(i) - 'a']--;
        }
        for (int count: record) {
            if (count != 0) { 
                return false;
            }
        }
        return true; 
    }
}

分析：
时间复杂度：O(n)，空间复杂度：O(1)。

349. 两个数组的交集

题目链接：https://leetcode.cn/problems/intersection-of-two-arrays/
文档讲解：https://programmercarl.com/0349.%E4%B8%A4%E4%B8%AA%E6%95%B0%E7%BB%84%E7%9A%84%E4%BA%A4%E9%9B%86.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
视频讲解：https://www.bilibili.com/video/BV1ba411S7wu

思路

使用数组来做哈希的题目，是因为题目都限制了数值的大小。而这道题目没有限制数值的大小，就无法使用数组来做哈希表了。而且如果哈希值比较少、特别分散、跨度非常大，使用数组就造成空间的极大浪费。此时就要使用另一种结构体了，Set。 Set不允许数据重复。
先建立一个HashSet遍历数组1，然后遍历数组2，如果数组2的值在HashSet中，则加入一个新的HashSet中作为结果。最后转换为数组返回。

代码

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<>();
        for (int i : nums1) {
            set1.add(i);
        }
        for (int i : nums2) {
            if (set1.contains(i)) {
                resSet.add(i);
            }
        }
        int[] arr = new int[resSet.size()];
        int j = 0;
        for(int i : resSet){
            arr[j++] = i;
        }
        
        return arr;
    }
}

分析：
时间复杂度：O(n + m)，空间复杂度：O(n)。

202. 快乐数

题目链接：https://leetcode.cn/problems/happy-number/
文档讲解：https://programmercarl.com/0202.%E5%BF%AB%E4%B9%90%E6%95%B0.html#%E6%80%9D%E8%B7%AF
视频讲解：无

思路

使用HashSet判断平方和sum是否重复出现，如果重复了就是return false，否则一直找到sum为1为止。

代码

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

分析：
时间复杂度：O(logn)，空间复杂度：O(1)。

1. 两数之和

题目链接：https://leetcode.cn/problems/two-sum/
文档讲解：https://programmercarl.com/0001.%E4%B8%A4%E6%95%B0%E4%B9%8B%E5%92%8C.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
视频讲解：https://www.bilibili.com/video/BV1aT41177mK

思路

本题需要一个集合来存放遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，也就是是否出现在这个集合。
由于本题不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，需要使用 key-value 结构来存放，key来存元素，value来存下标，所以需要使用map。

代码

class Solution {
   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]; 
        	if(map.containsKey(temp)){
            	res[1] = i;
            	res[0] = map.get(temp);
            	break;
        	}
        	map.put(nums[i], i); 
    	}
    	return res;
	} 
}