资料来源:代码随想录
哈希表是根据关键码的值而直接进行访问的数据结构。
比如:数组,关键码就是数组的索引下标。
一般哈希表都是用来快速判断一个元素是否在集合里/一个元素是否出现过。
哈希函数:把其他数据格式转化为不同的数值,映射为哈希表上的索引数字。
哈希碰撞:不同的数值映射到同一个索引下标的位置。
解决方法:
(1)拉链法:发生冲突的元素被存储到链表中。
(2)线性探测法:需要保证tablesize>datasize,用空位来存放冲突的元素。
三种常见的哈希结构:数组、set(集合)、map(映射)。
注意:使用数组来做哈希题目时,需要题目限制数值的大小。
set有三种可用的数据结构:
当我们要使用集合来解决哈希问题的时候,优先使用unordered_set,因为它的查询和增删效率是最优的,如果需要集合是有序的,那么就用set,如果要求不仅有序还要有重复数据的话,那么就用multiset。
定义一个record数组(哈希表)用来记录字符串s里字符出现的次数,均初始化为0。
把字符映射到哈希表上。最多有26个字符,所以tablesize=26即可,即哈希表的索引下标从0-25.
在遍历字符串s的时候,只要将s中各元素对应的哈希表中的值+1即可;在遍历字符串t的时候,再将t中各元素对应的哈希表中的值-1.
最后检查:record数组中如果有元素不为0,说明s和t一定是谁多或谁少了字符,return FALSE;元素均为0的话,说明是字母异位词,return TRUE。
class Solution {
public:
bool isAnagram(string s, string t) {
int record[26]={0}; //初始化一个有26个空位的数组,初值为0
for(int i=0; i
学会std::unordered_set这种数据结构的使用。
它可以用来存放数据,不需要对数据进行排序,且可以让数据不重复。
std::set和std::multiset底层实现都是红黑树,std::unordered_set的底层实现是哈希表, 使用unordered_set 读写效率是最高的,并不需要对数据进行排序,而且还不要让数据重复,所以选择unordered_set。
class Solution {
public:
vector intersection(vector& nums1, vector& nums2) {
unordered_set result_set; //定义一个无序集合来存放结果,这样可以给结果去重,满足“输出结果每个数都唯一”的要求
unordered_set nums_set(nums1.begin(),nums1.end());
//把数组nums1中的元素存放进一个无序集合num_set里,给数据去重
for(int num : nums2) //冒号前是实例化一个集合中包含的元素,冒号后是要遍历的集合
//意思是遍历nums2集合中的每一个元素
{
if(nums_set.find(num)!=nums_set.end())
//在nums_set集合中寻找nums2集合中的num元素,返回的结果不是nums_set的末尾
//说明在nums_set集合中找到了这个元素
//如果是末尾,说明走了一遍都没找到这个元素
{
result_set.insert(num); //把找到的元素放到结果集合里
}
}
return vector (result_set.begin(),result_set.end()); //返回交集
}
};
上面这种做法是用集合做,数据量有限的话还可以用数组做:
class Solution {
public:
vector intersection(vector& nums1, vector& nums2) {
unordered_set result_set;
int hash[1000]={0}; //定义一个数组,数组长度最大为1000
for(int num : nums1)
{
hash[num]=1;
}
//如果一个num在nums1中出现,在哈希表中把对应位置的数改成1
for(int num : nums2)
{
if(hash[num]==1)
{
result_set.insert(num);
}
//如果nums2中的元素num在哈希表中对应位置的数为1,说明这个元素在nums1中也出现过
//即为相交的元素,放入结果集合
}
return vector(result_set.begin(),result_set.end());
}
};
class Solution {
public:
int getSum(int n)
{
int sum=0;
while(n) //一直循环
{
sum=sum+(n%10)*(n%10);
n=n/10; //先是个位平方,然后是十位,再然后是百位...
}
return sum;
}
bool isHappy(int n)
{
unordered_set set; //放结果
while(1)
{
int sum=getSum(n); //从上面接收一下计算好的sum
if(sum==1)
{
return true;
}
if(set.find(sum)!=set.end())
//能找到sum这个数,说明这个数之前出现过,所以已经出现循环了
{
return false;
}
else
{
set.insert(sum);
}
n=sum; //继续下一轮计算
}
}
};
因为在本地,我们不仅要知道元素有没有遍历过,还有知道这个元素对应的下标,需要使用 key value结构来存放,key来存元素,value来存下标,那么使用map正合适。
再来看一下使用数组和set来做哈希法的局限。
此时就要选择另一种数据结构:map ,map是一种key value的存储结构,可以用key保存数值,用value在保存数值所在的下标。
这道题目中并不需要key有序,选择std::unordered_map 效率更高!
思路:
在遍历数组的时候,向map查询是否有和当前遍历元素所匹配的数值(即相加等于target),如果map中有,就找到匹配对,返回下标值;如果没有,就把当前遍历元素以(key,value)即(数值,下标)的方式存进map,因为map存放的就是我们访问过的元素。
一些其它的知识:
map
如果用一个指针it来指向map中的元素:auto it=map.begin( ); 那么解引用*it将得到map中的第一个元素pair< >。
然后可以再接收pair中的两个元素:
it->first将得到key值,it->second将得到value值。
auto在这里起到自动类型识别的作用。用它来定义一个指针,就不用再去想指针是什么类型的了。
迭代器.find( ),如果没有找到的话,指向的是末尾元素的下一个,即.end( )。迭代器的使用方法和指针类似。
class Solution {
public:
vector twoSum(vector& nums, int target) {
//先初始化一个map用来存放已经访问过的元素
std::unordered_map map;
for(int i=0; isecond,i}; //则返回匹配的下标和数组中当前元素的下标
}
//没找到:将当前元素存入map,因为map用来存放我们已经访问过的元素
map.insert(pair(nums[i],i));
}
return {};
}
};
本题的四个重点:
(1)为什么会想到用哈希表?
因为我们要在数组中寻找是否有和当前元素匹配的值,即查询一个值是否在数组中出现过,所以要用哈希表。
(2)哈希表为什么用map?
用数组的话,如果数组元素少而哈希表太大,就会造成内存空间的浪费;而set是一个集合,里面只能存放key值,而我们既需要记录元素的值,又需要记录元素的下标,所以用map。
(3)本题map是用来存什么的?
存我们已经访问过的元素的值和下标。
(4)map中的key和value用来存什么?
key用来存元素的值,value用来存元素的下标。
【Leetcode】map[key]++的理解与用法_map[]++_fighting_!的博客-CSDN博客
在unorder_map中,可以使用方括号访问键对应的值map[key] ,map[key]是这个key值对应的value。需要注意的是,如果该 key 不存在,C++ 会自动创建这个 key,并把 map[key] 赋值为 0。
所以我们可以通过map[key]++来直接创建key且使key对应的value值+1,该句代码可以用在需要计数的情况下。
那么会产生一个问题(是我个人在第一次接触时所产生的问题):用map[key]++可以创建key,那么用map[key]--是不是可以删除key呢?
经验证:不是。通过++来建立键,但不可以通过--来删除键,删除只能试用erase函数来删除键。
思路:我们只需要得到满足条件的元组的数量即可,不需要得到具体的元组值。
首先遍历A和B两个数组,统计两个数组元素之和(作为key值)和出现的次数(作为value值),放到unordered_map中,对结果进行去重。
然后遍历C和D两个数组,在刚刚的map中寻找是否有0-(c+d)这个值,即为满足a+b+c+d=0这个要求的值。如果有的话,说明找到了符合要求的元组,将map中0-(c+d)这个值对应的value赋给count,统计出符合要求的元组的数量。
class Solution {
public:
int fourSumCount(vector& nums1, vector& nums2, vector& nums3, vector& nums4) {
unordered_map map;
//定义一个map来存放nums1和nums2遍历的结果
//key存放a+b的值,value存放a+b出现的次数
for(int a : nums1)
{
for(int b : nums2)
{
map[a+b]++; //计算a+b的值作为key,并将对应的value加1,。注意结果已经去重
}
}
int count=0; //统计a+b+c+d=0出现的次数
for(int c : nums3)
{
for(int d : nums4)
{
if(map.find(0-(c+d))!=map.end()) //找到了符合a+b+c+d=0的元组
{
count=count+map[0-(c+d)]; //map[0-(c+d)]是这个值对应的value
}
}
}
return count;
}
};
(1)暴力解法
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
for(int i=0; i
(2)哈希解法
思路:维护一个长度为26的数组,在里面相对应的位置存放进magazine每个字符出现的次数,然后用ransomNote来验证这个数组中是否包含了ransomNote所需要的所有字符。
class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
int record[26]={0};
if(ransomNote.size()>magazine.size())
{
return false;
}
for(int i=0; i
双指针法。
首先将数组排序。然后定义下标:i从0的地方开始,left从i+1的地方开始,right定义在数组结尾的地方。在数组中找到abc使得a+b+c=0,其中a=nums[i] b=nums[left] c=nums[right]。
如何移动指针?如果nums[i]+nums[left]+nums[right]>0,说明三数之和大了,因为数组是排序的,所以right下标应该左移,这样才能让三数之和减小。
如果nums[i]+nums[left]+nums[right]<0,说明三数之和小了,就让left下标右移,直到left和right相遇,说明还是不够大,这时需要移动i。所以有一个关于i的for循环。
去重和双指针同时收缩没懂。
class Solution {
public:
vector> threeSum(vector& nums) {
//定义一个容器存放结果
vector> result;
sort(nums.begin(),nums.end());
for(int i=0; i0)
{
return result;
}
//nums[i]是三个数里最小的一个了,如果最小的都大于0,那么和不可能为0,直接返回结果
//对a去重(没懂)
if(i>0 && nums[i]==nums[i-1])
{
continue;
}
//定义双指针
int left=i+1;
int right=nums.size()-1;
while(left0)
{
right--;
}
else if(nums[i]+nums[left]+nums[right]<0)
{
left++;
}
else
{
result.push_back(vector{nums[i],nums[left],nums[right]});
//对b和c去重(没懂)
while(right>left && nums[right]==nums[right-1])
{
right--;
}
while(right>left && nums[left]==nums[left+1])
{
left++;
}
//找到答案,双指针同时收缩(没懂)
right--;
left++;
}
}
}
return result;
}
};
看不懂!!!!