哈希表相关的力扣题和讲解和Java、C++常用的数据结构（哈希法）

（来源于代码随想录）

一、什么时候适用什么样的结构。

1.java中

Java 中的数据结构及其使用场景

1.1 HashSet：

底层实现：哈希表。
特点：无序集合，元素唯一。
使用场景：
需要快速查找、插入和删除操作，并且不关心元素的顺序。
适合于需要去重的集合，例如存储唯一的用户ID或配置项。

1.2 TreeSet：

底层实现：红黑树。
特点：有序集合，元素唯一，按自然顺序或指定的比较器排序。
使用场景：
需要保持元素的排序，并且需要高效的顺序相关操作（如范围查询）。
适合于需要有序集合的应用场景，例如任务调度系统或有序数据处理。

1.3 LinkedHashSet：

底层实现：哈希表和双向链表。
特点：保持插入顺序的无序集合，元素唯一。
使用场景：
需要保持元素的插入顺序，并且需要高效的查找、插入和删除操作。
适合于需要插入顺序的集合，如实现缓存机制或历史记录功能。

1.4 HashMap：

底层实现：哈希表。
特点：无序的键值对集合，键唯一，值可以重复。
使用场景：
需要高效的键值对查找、插入和删除操作，不关心键值对的顺序。
适合于实现字典、缓存、配置管理等场景。

1.5 TreeMap：

底层实现：红黑树。
特点：有序的键值对集合，键唯一，按键的自然顺序或指定的比较器排序。
使用场景：
需要保持键的有序性，并进行高效的范围查询操作。
适合于需要按键排序的场景，例如实现排序的配置项存储或基于键的范围查询。

1.6 LinkedHashMap：

底层实现：哈希表和双向链表。
特点：保持插入顺序的键值对集合，键唯一。
使用场景：
需要保持插入顺序，并且需要高效的键值对查找、插入和删除操作。
适合于实现有序缓存（如最近最少使用缓存）或需要记录插入顺序的映射。

1.7 总结

HashSet 和 HashMap 提供了基于哈希的高效查找和操作，适合不关心顺序的场景。
TreeSet 和 TreeMap 提供了基于红黑树的有序操作，适合需要排序和范围查询的场景。
LinkedHashSet 和 LinkedHashMap 提供了保持插入顺序的功能，适合需要记录元素插入顺序的场景。

2. c++中

2.1 std::unordered_set：

底层实现：哈希表。
特点：无序集合，提供常数时间复杂度的平均增、删、查操作。
适用场景：当需要高效的查找操作，并且元素的顺序无关紧要时使用。

2.2 std::set：

底层实现：红黑树（平衡二叉搜索树）。
特点：有序集合，元素按照一定顺序存储，提供对数时间复杂度的增、删、查操作。
适用场景：当需要有序集合，且集合中不允许重复元素时使用。

2.3 std::multiset：

底层实现：红黑树（平衡二叉搜索树）。
特点：有序集合，允许重复元素。
适用场景：当需要有序集合，并且允许重复元素时使用。

2.4 std::unordered_map：

底层实现：哈希表。
特点：无序的键值对集合，提供常数时间复杂度的平均增、删、查操作。
适用场景：当需要高效的键值对查找，且键值对的顺序无关紧要时使用。

2.5 std::map：

底层实现：红黑树（平衡二叉搜索树）。
特点：有序的键值对集合，键是唯一的，提供对数时间复杂度的增、删、查操作。
适用场景：当需要有序的键值对集合，并且键值对的顺序是重要的时使用。

2.6 std::multimap：

底层实现：红黑树（平衡二叉搜索树）。
特点：有序的键值对集合，键允许重复，提供对数时间复杂度的增、删、查操作。
适用场景：当需要有序的键值对集合，并且允许键重复时使用。

3 代码随想录中对与哈希法的总结

二、题目和讲解

1 用数组

242. 有效的字母异位词

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

/**
 * 242. 有效的字母异位词 字典解法
 * 时间复杂度O(m+n) 空间复杂度O(1)
 */
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是字母异位词
    }
}

383. 赎金信

给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。

如果可以，返回 true ；否则返回 false 。

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

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
            int[] arr=new int[26];
            for(int i=0;i<magazine.length();++i){
                arr[magazine.charAt(i)-'a']++;
            }
            for(int i=0;i<ransomNote.length();++i){
                arr[ransomNote.charAt(i)-'a']--;
            }
            for(int a:arr){
                if(a<0){
                    return false;
                }
            }
            return true;
    }
}

2. 用set的题

350. 两个数组的交集 II

给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。

使用HashSet

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

使用Hash数组

class Solution {
    public int[] intersection(int[] nums1, int[] nums2) {
        int[] hash1 = new int[1002];
        int[] hash2 = new int[1002];
        for(int i : nums1)//将nums1出现的数字次数进行存储
            hash1[i]++;
        for(int i : nums2)
            hash2[i]++;
        List<Integer> resList = new ArrayList<>();
        for(int i = 0; i < 1002; i++)
            if(hash1[i] > 0 && hash2[i] > 0)//如果i都大于0，证明都都存在，所以直接添加到List集合。
                resList.add(i);
        int index = 0;
        int res[] = new int[resList.size()];
        for(int i : resList)//返回数组，所以转为数组
            res[index++] = i;
        return res;
    }
}