哈希表基础课程笔记

1. 什么是哈希表

哈希表（Hash Table）又称为散列表，是一种基于关键码（Key）直接进行访问的数据结构。简单理解，数组其实也是一种哈希表。哈希表通过关键码映射到数组的索引，从而实现快速访问。

1.1 哈希表的应用

哈希表主要用于快速判断某个元素是否存在于集合中。例如，查询一个名字是否在学校名单中。哈希表可以将查找时间复杂度降低到 ( O(1) )。

2. 哈希函数

哈希函数用于将关键码（如学生姓名）映射到哈希表的索引位置。常见做法是将关键码通过特定编码转化为数值（hashCode），再通过取模操作将其限制在哈希表范围内。

2.1 哈希函数处理

• 如果 hashCode 得到的数值大于哈希表大小，需要取模操作 hashCode % tableSize。
• 哈希表大小过小时，即使哈希函数均匀分布，仍可能导致多个关键码映射到相同索引，形成哈希碰撞。

3. 哈希碰撞

哈希碰撞是指不同的关键码映射到相同的哈希表索引位置。例如，小李和小王都映射到索引 1。常用的解决方法包括：

3.1 拉链法

将发生冲突的元素存储在链表中，通过索引快速访问链表即可。

3.2 线性探测法

利用哈希表中的空位解决碰撞问题。如果索引位置发生冲突，则继续查找下一个空位放置数据。

242. 有效的字母异位词

题目描述

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

示例 1:

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

示例 2:

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

说明:
你可以假设字符串只包含小写字母。

解题思路

1. 创建一个大小为 26 的数组 record，用于记录每个字母出现的次数。

   • 因为题目说明字符串只包含小写字母，所以每个字母都可以通过 char - 'a' 得到一个 0 到 25 之间的索引，对应到数组 record 中。

2. 遍历字符串 s，增加对应字母的计数。

   • 对于 s 中的每个字符，通过 record[s.charAt(i) - 'a']++ 来记录每个字母的出现次数。

3. 遍历字符串 t，减少对应字母的计数。

   • 对于 t 中的每个字符，通过 record[t.charAt(i) - 'a']-- 来减少每个字母的出现次数。
   • 如果在此过程中，发现某个字符的计数小于 0，说明 t 中出现了 s 中没有的字符，返回 false。

4. 遍历数组 record 检查所有计数是否为 0。

   • 如果数组中每个位置的计数都是 0，则说明 t 是 s 的字母异位词，否则返回 false。

代码实现

class Solution {public boolean isAnagram(String s, String t) {// 如果两个字符串长度不相等，直接返回 falseif (s.length() != t.length()) {return false;}int[] record = new int[26];// 记录 s 中每个字符的出现次数for (int i = 0; i < s.length(); i++) {record[s.charAt(i) - 'a']++;}// 减去 t 中每个字符的出现次数for (int i = 0; i < t.length(); i++) {record[t.charAt(i) - 'a']--;// 如果出现某个字符计数小于 0，说明 t 中有多余字符if (record[t.charAt(i) - 'a'] < 0) {return false;}}// 检查所有计数是否为 0for (int count : record) {if (count != 0) {return false;}}return true;}
}

349. 两个数组的交集

题目描述

给定两个数组，编写一个函数来计算它们的交集。

示例:

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2]

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [9,4] (结果中的每个元素都是唯一的，顺序可以是任意的)

解题思路

1. 处理特殊情况
   首先判断输入数组是否为空或长度为 0，如果是，则直接返回空数组。

2. 使用集合（Set）去重并快速查找

   • 使用 Set 数据结构将 nums1 中的所有元素存入 set1，从而去重。
   • 遍历 nums2 数组，检查其中每个元素是否在 set1 中，如果在，将其添加到结果集合 resultset 中。
   • Set 可以确保结果中的元素都是唯一的。

3. 将结果集合转换为数组并返回
   最后，将 resultset 中的元素转换成数组返回。

反思

命名规范

在编写代码时应当遵循驼峰命名法。例如，resultset 应改为 resultSet，以提高代码的可读性。

length 属性不需要小括号

在 Java 中，数组的 length 是一个属性，而不是一个方法，因此不需要小括号。要注意区分这类细节，避免出现不必要的错误。

代码优化

resultset.stream().mapToInt(x -> x).toArray() 是一种方便的方式将集合转换为数组，比手动遍历转换更简洁和高效。

这道题展示了集合在处理数组去重和交集问题中的高效性，是一个典型的应用案例。

代码实现

import java.util.Set;
import java.util.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> resultset = new HashSet<>();// 将 nums1 中的元素添加到 set1 中for (int i : nums1) {set1.add(i);}// 检查 nums2 中的元素是否在 set1 中for (int i : nums2) {if (set1.contains(i)) {resultset.add(i);}}// 将结果集合转换为数组并返回return resultset.stream().mapToInt(x -> x).toArray();}
}

202. 快乐数

题目描述

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

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

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

示例

• 输入: 19
• 输出: true

解释：
1² + 9² = 82
8² + 2² = 68
6² + 8² = 100
1² + 0² + 0² = 1

解题思路

1. 定义一个辅助函数 pingfanghe(int n)
   该函数用于计算 n 每一位数字的平方和。例如，19 的平方和为 1² + 9² = 82。
   使用一个循环将 n 逐位处理，并计算每位的平方和。

2. 使用集合 (Set) 检测循环
   为了避免程序进入无限循环，我们可以用 Set 来存储每次计算得到的平方和。如果在计算过程中发现某个平方和已经存在于 Set 中，说明进入了循环，直接返回 false。

3. 循环判断

   • 在每次循环中，计算 n 的平方和。
   • 如果平方和等于 1，返回 true，表示是快乐数。
   • 如果平方和已经存在于 Set 中，说明进入了无限循环，返回 false。

反思

• 得更新 n 的值：在每次循环中，必须更新 n 的值为当前的平方和，确保能够继续正确地进行计算。
• 注意 pingfanghe 方法的除法逻辑：应直接使用 n / 10 来更新 n 的值，从而正确计算每一位数字。

代码实现

class Solution {public int pingfanghe(int n){int sum=0;int num = n;int dis = 0;while(num>0){dis = num%10;sum = sum + dis*dis;num = (num-dis)/10;}return sum;}public boolean isHappy(int n) {Set<Integer> set1 = new HashSet<>();int sum = pingfanghe(n);while(sum!=1){if(set1.contains(sum)){return false;}else{set1.add(sum);sum = pingfanghe(sum);}}return true;}
}

1. 两数之和

题目描述

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回它们的数组下标。

注意：

• 你可以假设每种输入只会对应一个答案。
• 数组中同一个元素不能使用两遍。

示例:

• 输入: nums = [2, 7, 11, 15], target = 9
• 输出: [0, 1]
  解释: nums[0] + nums[1] = 2 + 7 = 9

解题思路

1. 使用哈希表 (HashMap) 记录已经遍历过的元素

   • 遍历数组 nums，对于每个元素 nums[i]，计算 target - nums[i] 的差值 diff。
   • 检查哈希表中是否存在 diff。
     • 如果存在，则说明找到了两个数，返回它们的下标。
     • 如果不存在，则将当前的元素 nums[i] 及其下标 i 存入哈希表中。

2. 使用哈希表的优势
   通过哈希表，可以在遍历过程中立即找到与当前元素配对的目标数，从而在 O(1) 时间复杂度内完成查找。整体算法的时间复杂度为 O(n)。

代码实现

class Solution {public int[] twoSum(int[] nums, int target) {Map<Integer,Integer> map1 = new HashMap<>();for(int i=0;i<nums.length;i++){int dis = target-nums[i];if(map1.containsKey(dis)){return new int []{i, map1.get(dis)};}else{map1.put(nums[i],i);}}return null;}
}