⚡刷题计划day6继续，可以点个免费的赞哦~
今天是哈希表专题，哈希中理论知识会多一些，往期可看专栏，关注不迷路，
您的支持是我的最大动力🌹~
目录
今天是哈希表专题，哈希中理论知识会多一些，往期可看专栏，关注不迷路，
题目一：202. 快乐数
leetcode：202. 快乐数
(https://leetcode.cn/problems/happy-number/description/)
我们可以先举几个例子。我们从 7 开始。如图我们可以不断重复该的过程，直到我们得到 1。因为我们得到了 1，我们知道 7 是一个快乐数，函数应该返回 true。
再举一个例子，让我们从 116 开始。通过反复通过平方和计算下一个数字，我们最终得到 58，再继续计算之后，我们又回到 58。由于我们回到了一个已经计算过的数字，可以知道有一个循环，因此不可能达到 1。所以对于 116，函数应该返回 false。
结合题目，至此我们可以初步猜测，正常大致可能会有下面两种情况：
1.最终会得到 1。
2.最终会进入循环。
了解：但是如果考虑全面一些可能会想到另一点：3.如果值越来越大，最终接近无穷大怎么办呢？
我们可以仔细想想，每一位数的最大数字的下一位数是多少。
Digits Largest Next 1 9 81 2 99 162 3 999 243 4 9999 324 13 9999999999999 1053 我们由此可以发现：
对于 3 位数的数字，它不可能大于 243。这意味着它要么被困在 243 以下的循环内，要么跌到 1。
4 位或 4 位以上的数字在每一步都会丢失一位，直到降到 3 位为止。
结语：所以最终还是到1、2两种情况。可以排除第三张选择。
即使在代码中你不需要处理第三种情况，你仍然需要理解为什么它永远不会发生，不处理它，考虑全面。
通过图2，我们可以很自然的想到两种思路：
1.因为我们需要反复检查其中n的下一个数是否出现重复（导致循环），所以可以使用哈希集合，时间复杂度O(1)。
2.看这个形式，难道你没有想起链表吗，可不要因为现在是哈希专题思维就局限与哈希了，这不就是咱们之前链表专题的循环链表嘛，一个思想，爽了爽了。
以下给出具体解法：
法一：用哈希集合检测循环
算法拆分可大致有两个步骤：
1.给定数字n，怎么拆解每个数，它的下一个数字是什么？
2.根据数字n判定是否是1或是否进入了一个循环
注：无限循环的意思就是下一个数值与之前的重复了，就会循环
第一部分，数位分离，求平方和
int sum = 0;
while (n>0){
int d = n%10;
n /= 10;
sum += d * d;
}第二部分，我们可以使用哈希集合，每次生成下一个数字，检查其是否在哈希集合中。
注：我们使用哈希集合而不是向量、列表或数组的原因是因为我们反复检查其中是否存在某数字。检查数字是否在哈希集合中需要 O(1) 的时间，而对于其他数据结构，则需要 O(n) 的时间。
AC代码
class Solution {
public boolean isHappy(int n) {
Set<Integer> infer = new HashSet<>();
while (n!=1 && !infer.contains(n)){
infer.add(n);
n = getNext(n);
}
return n==1;//比较妙，不用去分类return什么true或false来
}
public int getNext(int n){
int sum = 0;
while (n>0){
int d = n%10;
n /= 10;
sum += d * d;
}
return sum;
}
}法二：快慢指针
我们观察以上图例，不知道你是否想起了我们前几天的链表专题中的循环链表，此题我们同样可以使用这个思想。
通过反复调用 getNext(n) 得到的链是一个隐式的链表。隐式意味着我们没有实际的链表节点和指针，但数据仍然形成链表结构。起始数字是链表的头 “节点”，链中的所有其他数字都是节点。next 指针是通过调用 getNext(n) 函数获得。
意识到我们实际有个链表，那么这个问题就可以转换为检测一个链表是否有环。因此我们在这里可以使用弗洛伊德循环查找算法，使用快慢指针的思想。
class Solution {
public boolean isHappy(int n) {
int slow = n;// 初始化慢指针为n
int fast = getNext(n);// 计算n的下一个数，并初始化快指针
while(fast !=1 && fast !=slow){
slow = getNext(n);// 慢指针移动一步
fast = getNext(getNext(fast));// 快指针移动两步，因为我们要检测是否进入循环
}
return fast==1;
}
public int getNext(int n){
int sum = 0;
while (n>0){
int d = n%10;
n /= 10;
sum += d * d;
}
return sum;
}
}题目二：1. 两数之和【力扣第一题，噩梦的开始】
前言:
力扣第一题，有人相爱，有人夜里开车看海，有人leetcode第一题都做不出来。
leetcide：1. 两数之和
(https://leetcode.cn/problems/two-sum/description/)
法一：暴力枚举
两层for循环暴力即可：
class Solution {
public int[] twoSum(int[] nums, int target) {
int n = nums.length;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (nums[i] + nums[j] == target) {
return new int[]{i, j};
}
}
}
return new int[0];
}
}-
时间复杂度：O(N2)，其中 N 是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。
-
空间复杂度：O(1)。
法二：哈希表
关于什么时候使用哈希法，当我们需要查询一个元素是否出现过，或者一个元素是否在集合里的时候，就要第一时间想到哈希法。
本题呢，我就需要一个集合来存放我们遍历过的元素，然后在遍历数组的时候去询问这个集合，某元素是否遍历过，也就是 是否出现在这个集合。
那么我们就应该想到使用哈希法了。
因为本题，我们不仅要知道元素有没有遍历过，还要知道这个元素对应的下标，需要使用 key value结构来存放，key来存元素，value来存下标，那么使用map正合适。
详见代码注释
AC代码
class Solution {
public int[] twoSum(int[] nums, int target) {
// 创建一个HashMap，用于存储数组中每个元素的值作为键，其索引作为值
Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
// 遍历数组nums中的每个元素
for (int i = 0; i < nums.length; ++i) {
// 检查hashtable中是否存在target减去当前元素nums[i]的值
// 如果存在，说明找到了两个数，它们的和等于target
if (hashtable.containsKey(target - nums[i])) {
// 返回一个新数组，包含之前存储在hashtable中的索引和当前索引i
return new int[]{hashtable.get(target - nums[i]), i};
}
// 将当前元素的值和它的索引存入hashtable
hashtable.put(nums[i], i);
}
// 如果遍历完数组后没有找到符合条件的两个数，返回一个空数组
return new int[0];
}
}-
时间复杂度：O(N)，其中 N 是数组中的元素数量。对于每一个元素 x，我们可以 O(1) 地寻找 target - x。
-
空间复杂度：O(N)，其中 N 是数组中的元素数量。主要为哈希表的开销。
总结：多涉及到「两个变量」的题目，都可以枚举其中一个变量，把它当成常量看待，从而转换成「一个变量」的问题。
代码实现时，通常来说「枚举右，寻找左」是更加好写的。
哈希表内容补充--哈希冲突
今天任务只有两道题，然后还需要了解哈希冲突及其解决方案，明天的题目会与详细冲突相关。
解决哈希冲突的基本两个方法是链地址法和开放寻址法（线性探测法）
1.链地址法
2.开放寻址法
具体解释及代码可以参考hello算法里的讲解，以下是链接：
6.2 哈希冲突 - Hello 算法 (hello-algo.com)
(https://www.hello-algo.com/chapter_hashing/hash_collision/)
419
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
