当我们遇到了要快速判断一个元素是否出现集合里的时候,就要考虑哈希法。文章讲解:代码随想录
补充知识点
vector:
vector是STL的动态数组,可以在运行中根据需要改变数组的大小。
因为它以数组的形式储存,所以它的内存空间是连续的。
vector的头文件为#include<vector>
常用方法:
1.vector<int>a 创建一个动态数组a,a的默认初值为0
2.vector<int >b(a) 将a中的元素复制到b中
3.vetcor<int>a(100) 将数组a的元素定义为100个,默认初始值为0
4.vector<int>a(100,6) 定义100个值为6的元素
5.vector<string>a(10,"null") 定义10个值为null的元素
6.vector<string>a(10,"hello") 定义10个值为hello的元素
7.vector<string>b(a.begin(),a.end()) 将动态数组a的元素值复制到b中
常用操作:
1.a.push_back(100) 在尾部加入一个值为100的元素
2.a.size() 返回数组中元素的个数
3.bool isEmpty=a.empty() 判断a是否为空,若为空返回true,若不为空则返回false
4.cout<<a[0]<<endl 输出数组的大小
5.a.insert(a.begin+i,k) 在第i个元素前插入k
6.a.insert(a.end(),10,5) 在末尾插入10个值为5的元素
7.a.pop_back 删除末尾元素
8.a.erase(a.begin()+i,a.begin()+j) 将[i,j-1]的元素都删除
9.a.erase(a.begin()+i) 将第i+1个元素删除
10.a.resize(n) 将数组重置为n个元素
11.a.clear() 清空数组
12.reverse(a.begin(),a.end()) 将数组逆转
13.sort(a.begin(),a.end()) 将数组从小到大排序
unordered_set:
成员方法 功能
begin() 返回指向容器中第一个元素的正向迭代器。
end(); 返回指向容器中最后一个元素之后位置的正向迭代器。
cbegin() 和 begin() 功能相同,只不过其返回的是 const 类型的正向迭代器。
cend() 和 end() 功能相同,只不过其返回的是 const 类型的正向迭代器。
empty() 若容器为空,则返回 true;否则 false。
size() 返回当前容器中存有元素的个数。
max_size() 返回容器所能容纳元素的最大个数,不同的操作系统,其返回值亦不相同。
find(key) 查找以值为 key 的元素,如果找到,则返回一个指向该元素的正向迭代器;反之,则返回一个指向容器中最后一个元素之后位置的迭代器(如果 end() 方法返回的迭代器)。
count(key) 在容器中查找值为 key 的元素的个数。
equal_range(key) 返回一个 pair 对象,其包含 2 个迭代器,用于表明当前容器中值为 key 的元素所在的范围。
emplace() 向容器中添加新元素,效率比 insert() 方法高。
emplace_hint() 向容器中添加新元素,效率比 insert() 方法高。
insert() 向容器中添加新元素。
erase() 删除指定元素。
clear() 清空容器,即删除容器中存储的所有元素。
swap() 交换 2 个 unordered_map 容器存储的元素,前提是必须保证这 2 个容器的类型完全相等。
bucket_count() 返回当前容器底层存储元素时,使用桶(一个线性链表代表一个桶)的数量。
max_bucket_count() 返回当前系统中,unordered_map 容器底层最多可以使用多少桶。
bucket_size(n) 返回第 n 个桶中存储元素的数量。
bucket(key) 返回值为 key 的元素所在桶的编号。
load_factor() 返回 unordered_map 容器中当前的负载因子。负载因子,指的是的当前容器中存储元素的数量(size())和使用桶数(bucket_count())的比值,即 load_factor() = size() / bucket_count()。
max_load_factor() 返回或者设置当前 unordered_map 容器的负载因子。
rehash(n) 将当前容器底层使用桶的数量设置为 n。
reserve() 将存储桶的数量(也就是 bucket_count() 方法的返回值)设置为至少容纳count个元(不超过最大负载因子)所需的数量,并重新整理容器。
hash_function() 返回当前容器使用的哈希函数对象。map:
函数名 功能
my_map.insert()或按照数组直接赋值 插入
my_map.find() 擦查找一个元素
my_map.clear() 清空
my_map.erase() 删除一个元素
my_map.size() map的长度大小
my_map.begin() 返回指向map头部的迭代器
my_map.end() 返回指向map末尾的迭代器
my_map.rbegin() 返回一个指向map尾部的逆向迭代器
my_map.rend() 返回一个指向map头部的逆向迭代器
my_map.empty() map为空时返回true
swap() 交换两个map,两个map中所有元素都交换
242.有效的字母异位词
题目链接/文章讲解/视频讲解:代码随想录
给定两个字符串 s 和 t ,编写一个函数来判断 t 是否是 s 的字母异位词。
示例 1: 输入: s = "anagram", t = "nagaram" 输出: true
示例 2: 输入: s = "rat", t = "car" 输出: false
说明: 你可以假设字符串只包含小写字母。
思路:
- 数组的值相互抵消
- 关键在于a-z与0-25的对应关系,索引为0-25的record数组的数值就代表相应字母的个数
- false条件就是字母个数出现不一致,即不为0
class Solution {
public:
bool isAnagram(string s, string t) {
int record[26] = {0};
//a-z对应0-25
for(int i = 0; i < s.size(); i++){
record[s[i] - 'a']++; //出现哪个字母就把相应下标数组的值+1
}
for(int i = 0; i < t.size(); i++){
record[t[i] - 'a']--; //出现哪个字母就把相应下标数组的值-1
}
//不需要判断string大小
for(int i = 0; i < 26; i++){
if(record[i] != 0) //字母数量一直才能是0,有不一致就false
return false;
}
return true;
}
};
- 时间复杂度: O(n)
- 空间复杂度: O(1)
349. 两个数组的交集
题目链接/文章讲解/视频讲解: 代码随想录
给定两个数组 nums1
和 nums2
,返回 它们的交集 。输出结果中的每个元素一定是 唯一 的。我们可以 不考虑输出结果的顺序 。
输入:nums1 = [1,2,2,1], nums2 = [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
方法一:数组
思路 :如果出现了数组那就存为1,遍历判断是1后映射到哈希表
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
int hash[1005] = {0};
unordered_set<int>result;
for(int i = 0; i < nums1.size(); i++)
hash[nums1[i]] = 1; //只需要知道出现过哪个元素,不需要知道多少
for(int i = 0; i < nums2.size(); i++)
if(hash[nums2[i]] == 1) //如果出现过那就插入
result.insert(nums2[i]);
return vector<int>(result.begin(),result.end());//固定语法
}
};
- 时间复杂度: O(m + n)
- 空间复杂度: O(n)
方法二:set
思路:先把nums1的元素映射到哈希表上,就可以得到哈希表
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
unordered_set<int> result;
unordered_set<int> nums_set(nums1.begin(),nums1.end()); //unordered_set原理是哈希表,可以去重
for(int num : nums2){
/*当我们使用std::set容器存储一组数字时,可以使用find()函数来查找是否存在特定的数字。在这种情况下,nums_set是一个set对象,存储了一些数字。
nums_set.find(num)将搜索nums_set中是否存在数字num。如果num存在于nums_set中,find()函数将返回一个指向该数字的迭代器;否则,它将返回nums_set.end(),即指向nums_set最后一个元素的下一个位置的迭代器。
所以,nums_set.find(num) != nums_set.end()这个条件语句的意思是,如果num在nums_set中存在,也就是find()函数返回的迭代器不等于nums_set的结尾迭代器,则执行相应的操作。
这段代码常用于判断一个数字是否出现在set容器中,以便根据这个判断作出进一步的操作。*/
if(nums_set.find(num) != nums_set.end())
result.insert(num);
}
return vector<int>(result.begin(),result.end());
}
};
- 时间复杂度: O(mn)
- 空间复杂度: O(n)
这段代码常用于判断一个数字是否出现在set容器中,以便根据这个判断作出进一步的操作。
if(nums_set.find(num) != nums_set.end())
直接使用set 不仅占用空间比数组大,而且速度要比数组慢,set把数值映射到key上都要做hash计算,所以也不能盲目使用set。
202. 快乐数
题目链接/文章讲解/视频讲解: 代码随想录
目前为止唯一一道完完全全自己写出来的,让我快乐了
方法一:递归
class Solution {
public:
bool isHappy(int n) {
vector<int>temp;
if(n == 1 || n == 7 || n == 10)
return true;
if(n/10 == 0)
return false;
int sum = 0;
while(n){
int tmp = n % 10;
sum += tmp * tmp;
n /= 10;
}
return isHappy(sum);
}
};
方法二:哈希表
class Solution {
public:
// 取数值各个位上的单数之和
int getSum(int n) {
int sum = 0;
while (n) {
sum += (n % 10) * (n % 10);
n /= 10;
}
return sum;
}
bool isHappy(int n) {
unordered_set<int> set;
while(1) {
int sum = getSum(n);
if (sum == 1) {
return true;
}
// 如果这个sum曾经出现过,说明已经陷入了无限循环了,立刻return false
if (set.find(sum) != set.end()) {
return false;
} else {
set.insert(sum);
}
n = sum;
}
}
};
- 时间复杂度: O(logn)
- 空间复杂度: O(logn)
1. 两数之和
题目链接/文章讲解/视频讲解:代码随想录
方法一:枚举
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
for(int i = 0; i < nums.size(); i ++){
for(int j = i + 1; j < nums.size(); j++){
if(nums[i] + nums[j] == target)
return {i, j};
}
}
return {};
}
};
复杂度分析
时间复杂度:O(N^2) ),其中 N是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。
空间复杂度:O(1)。
方法二:map
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int,int>map;
for(int i = 0; i < nums.size(); i++){
//遍历当前元素,并在map中寻找是否有匹配的key
//迭代器语法
auto iter = map.find(target - nums[i]);
if(iter != map.end())
return {iter->second,i};
//如果没找到匹配对,就把访问过的元素和下标加入到map中
map.insert(pair<int,int>(nums[i], i));
}
return {};
}
};
复杂度分析
时间复杂度:O(N),其中 N是数组中的元素数量。对于每一个元素 x,我们可以 O(1) 地寻找 target - x。
空间复杂度:O(N),其中 N 是数组中的元素数量。主要为哈希表的开销。