哈希表基础
说到哈希表首先想到的自然是哈希值,平时用磁力链接的时候(magnet:?xt=urn:btih:)后面加的那40位十六进制的东西就是哈希值,所以理论上来说,只要别的节点上传了,是不是随便输入都有可能得到想要的资源(呆傻问题勿理);
扯远了,首先了解哈希表工作原理:哈希表的本质就是数组,将待处理数据通过特定的哈希编码得到对应哈希表里的索引位置。
若经过哈希函数处理以后得到的索引值大于哈希表的长度,则会出现同一索引值对应多个不同数据的情况,这种异常称哈希碰撞;
一般哈希碰撞有两种解决方法, 拉链法和线性探测法:
拉链法:即将所有冲突的元素放在同一个链表上,可以用此方法缩短哈希表的长度;既不会因为数组空值浪费内存,也不会因为链表过长导致访问效率降低;
线性探测法:
本质上是在数组中寻找一个还未被使用的位置,将新的值插入;线性探测法需要保证tableSize大于dataSize,然后线性插入即可;
常见的三种哈希表结构
数组 set(集合) map(映射)
set
std::unordered_set底层实现为哈希表,std::set 和std::multiset 的底层实现是红黑树,红黑树是一种平衡二叉搜索树,所以key值是有序的,但key不可以修改,改动key值会导致整棵树的错乱,所以只能删除和增加;
map:
std::unordered_map 底层实现为哈希表,std::map 和std::multimap 的底层实现是红黑树;同理,std::map 和std::multimap 的key也是有序的(这个问题也经常作为面试题,考察对语言容器底层的理解);
std::set和std::multiset都是红黑树,但是使用方法是键值对:key value,和哈希表原理是一致的;map同理。
当待处理数据样本较小或者容易限制时,可采取数组;当数据量较大时,采取set;当Key与Val对应时,采取map;
总结:当需要快速判断一个元素是否出现集合里,使用哈希法
但是哈希法也是牺牲了空间换取了时间,因为我们要使用额外的数组,set或者是map来存放数据,才能实现快速的查找。
有效的字母异位词
给定两个字符串 *s*
和 *t*
,编写一个函数来判断 *t*
是否是 *s*
的字母异位词。
**注意:**若 *s*
和 *t*
中每个字符出现的次数都相同,则称 *s*
和 *t*
互为字母异位词。
示例 1:
输入: s = "anagram", t = "nagaram"
输出: true
示例 2:
输入: s = "rat", t = "car"
输出: false
提示:
1 <= s.length, t.length <= 5 * 104
s
和t
仅包含小写字母
进阶: 如果输入字符串包含 unicode 字符怎么办?你能否调整你的解法来应对这种情况?
读完题以后想到的是,先新建一个全为零的hash表,定义初始字符First为’a’,然后遍历整个字符串s,若取到和First相等的字符则让hash[i]++,再让First+=First,这样可以得到hash表里每一个索引位置的值,然后再对字符串t相同操作hash[j]–,最后判断hash[26]是否全为零;看了卡哥的思路,只觉得巧:
class Solution {
public:
bool isAnagram(string s, string t) {
int hash[26] = {0};//较小的数据量尽量用数组
for(int i = 0; i < s.size(); i++){
hash[s[i] - 'a']++;//一个语句完成了设置for循环+定义中间变量的事
}
for(int j = 0; j < t.size(); j++){
hash[t[j] - 'a']--;//太顶了,真的顶,
}
for(int k = 0; k < 26;k++){
if(hash[k] != 0){
return false;
}
}
return true;
}
};
两个数组的交集
给定两个数组 nums1
和 nums2
,返回 它们的交集 。
输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
示例 1:
输入:nums1 = [1,2,2,1], nums2 = [2,2]
输出:[2]
示例 2:
输入:nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出:[9,4]
解释:[4,9] 也是可通过的
提示:
1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000
学习使用set:
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
unordered_set<int> result_set;
unordered_set<int> nums1_set(nums1.begin(),nums1.end());
for(int i = 0; i < nums2.size(); i++){
int num = nums2[i];
if(nums1_set.find(num) != nums1_set.end()){
result_set.insert(num);
}
}
return vector<int>(result_set.begin(),result_set.end());
}
};
由于力扣限制了数组值的大小,所以这道题其实用数组也行:
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
unordered_set<int> result_set;
int hash[1024] = {0};
for(int num:nums1){ //简化的循环写法
/*for (int i = 0; i < nums1.size();i++) {
int num = nums1[i];
*/
hash[num] = 1;
}
for(int num:nums2){
if(hash[num] == 1){
result_set.insert(num);
}
}
return vector<int>(result_set.begin(),result_set.end());
}
};
快乐数
编写一个算法来判断一个数 n
是不是快乐数。
「快乐数」 定义为:
- 对于一个正整数,每一次将该数替换为它每个位置上的数字的平方和。
- 然后重复这个过程直到这个数变为 1,也可能是 无限循环 但始终变不到 1。
- 如果这个过程 结果为 1,那么这个数就是快乐数。
如果 n
是快乐数就返回 true
;不是,则返回 false
。
示例 1:
输入:n = 19
输出:true
解释:
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1
示例 2:
输入:n = 2
输出:false
提示:
1 <= n <= 231 - 1
什么快乐树,happy tree friends是吧)
不是哥们,闹呢,快乐不了一点;看了会儿完全是没啥思路,甚至连怎么求平方都没反应过来(难绷);
看了卡哥代码;哦哟牛批哦还有这种代码,真是简简又洁洁啊,你们也有这种代码吗:
class Solution {
public:
int getSum(int n){
int sum = 0;
while(n){//当n=0时退出循环,即加到最高位的平方时退出循环
sum += (n%10) * (n%10);//从低位开始求平方
n /= 10;//将n逐渐增加到最高位
}
return sum;
}
bool isHappy(int n) {
unordered_set<int> set;
while(true){
int sum = getSum(n);
if(sum == 1){//若sum=1,则直接退出循环
return true;
}
if(set.find(sum) != set.end()){//若读取到sum,说明此时已成死循环,则直接退出循环
return false;
}
else{
set.insert(sum);//将得到的sum加入set里
}
n = sum;
}
}
};
两数之和
给定一个整数数组 nums
和一个整数目标值 target
,请你在该数组中找出 和为目标值 target
的那 两个 整数,并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
示例 1:
输入:nums = [2,7,11,15], target = 9
输出:[0,1]
解释:因为 nums[0] + nums[1] == 9 ,返回 [0, 1] 。
示例 2:
输入:nums = [3,2,4], target = 6
输出:[1,2]
示例 3:
输入:nums = [3,3], target = 6
输出:[0,1]
提示:
2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
- 只会存在一个有效答案
**进阶:**你可以想出一个时间复杂度小于 O(n^2)
的算法吗?
第一次遇到这题还是四年前,麻了,当时想刷题提升下,结果第一题就整不出来复杂度小于O(n^2)的,有人相爱,有人看海,有人力扣第一题做不出来;
首先明确问题,在数组中寻找元素,找到相加符合条件的元素,若没有返回空,若有多对则只返回一组;由于涉及到的操作是数组里的元素相加、返回的值是元素的位置,且需要判断符合条件的值是否多次遍历,而判断一个元素是否出现过最适合的就是哈希表;此时我们不仅要知道数组里的元素是否出现过,同时需要知道存放对应元素位置对应的下标,而存储两个元素的哈希表就是map<key,val>;此时我们需要查找这个元素是否出现过,则数值正好对应key,元素组对应的下标则是对应val:
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int, int> hash;
for(int i = 0; i < nums.size(); i++){
int temp = target - nums[i];
unordered_map<int,int>::iterator iter = hash.find(temp);
if(iter != hash.end()){
return {iter->second , i};
}
hash.insert(pair<int,int>(nums[i],i));
}
return {};
}
};