242.有效的字母异位词
int a[3] = {0, 1, 2}; // 正确
int a[3]={0,1,2,3}; //错误,初始化值个数大于数组大小
int a[3]={0,2}; //错误,初始化值被跳过
int a[3]={0,1,}; //错误,初始化值被跳过(即使是最后一个元素,添加逗号也被认为是跳过)
int a[3]={0}; //正确,省略初始化最后一个元素,最后省略的元素初始化为0
int a[n]={0}; // 注意n必须为const类型,否则错误
class Solution {
public:
bool isAnagram(string s, string t) {
int hash[26]={0};
int i;
for(i = 0; i < s.size(); i++)
hash[s[i]-'a']++; // 并不需要记住字符a的ASCII,只要求出一个相对数值就可以了
for(i = 0; i < t.size(); i++)
hash[t[i]-'a']--;
for(i = 0; i < 26; i++)
if(hash[i] != 0)// 数组如果有的元素不为零0,说明字符串s和t 一定是谁多了字符或者谁少了字符。
return false;
return true; // 数组所有元素都为零0,说明字符串s和t是字母异位词
}
};
349. 两个数组的交集
** 哈希表最擅长的是解决给你一个元素,判断是否在这个集合里面出现过。遇到这种类似的场景,第一个条件反射就是我可能需要用到哈哈希表。
如果数值很大或者数值分布很散,适合set
在C++中,set 和 map 分别提供以下三种数据结构,其底层实现以及优劣如下表所示:
集合 底层实现 是否有序 数值是否可以重复 能否更改数值 查询效率 增删效率
std::set 红黑树 有序 否 否 O(log n) O(log n)
std::multiset 红黑树 有序 是 否 O(logn) O(logn)
std::unordered_set 哈希表 无序 否 否 O(1) O(1)
unordered_set哈希值直接映射,是一个可以无限存装的数组,效率快,本文用。
**
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
unordered_set<int> result_set;//存放结果,之所以用set是为了给结果集去重
unordered_set<int> num_set(nums1.begin(),nums1.end());
for(int num : nums2){
//存放结果,之所以用set是为了给结果集去重
if(num_set.find(num) != num_set.end())
{
result_set.insert(num);
}
}
return vector<int>(result_set.begin(),result_set.end());
}
};
本题后面 力扣改了 题目描述 和 后台测试数据,增添了 数值范围:
1 <= nums1.length, nums2.length <= 1000
0 <= nums1[i], nums2[i] <= 1000
所以就可以 使用数组来做哈希表了, 因为数组都是 1000以内的。
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
unordered_set<int> result_set;// 存放结果,之所以用set是为了给结果集去重
int hash[1005]={0};// 默认数值为0
for(int num : nums1){// nums1中出现的字母在hash数组中做记录
hash[num] = 1;
}
for(int num : nums2){// nums2中出现话,result记录
if(hash[num] == 1){
result_set.insert(num);
}
}
return vector<int>(result_set.begin(), result_set.end());
}
};
1. 两数之和
(什么时候会想到用哈希法?用哈希表来做一下映射,每当我们遇到要判断这个元素是否出现过或者是要判断 这个元素是否在这个集合里出现过的时候,我们第一反应就是我是不是可以用哈希法,我是不是应该用哪些哈希法的结构来做一下处理。)
这道题为什么会想到哈希法?
因为我们在遍历一个元素的时候,我们要存放我们之前遍历过的元素,我们要判断一个元素,我们是否之前遍历过,如果之前遍历过,我们就找到了一对,一对相加 是等于9。我们把遍历过的元素加到一个集合里面,每一次遍历一个新的位置之后,我们就判断我们寻找的元素是否在集合里面出现过,如果出现过,就是之前遍历过。这个集合用哈希表存储。
用哪一个哈希表呢?
我们要找一个元素,这个 元素 是否出现过,还要知道元素在数组里面的 下标 。map key(元素) value(下标)
我们要找的是元素是否出现过,那就应该把元素作为key,map的作用就是能在最快的时间去查找key是否在这个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++){
int s=target-nums[i];
auto iter=map.find(s);
// pair<int,int> iter=map.find(s);或许是因为找到的是pair的迭代器(迭代器不同于指针) 而不是pair
//https://blog.csdn.net/weixin_38736371/article/details/80873865
//find返回值是一个迭代器 不是pair
if(iter!=map.end()){
return {iter->second,i};
}
//map.insert(nums[i],i);
map.insert(pair<int, int>(nums[i], i));
}
return {};
}
};
//https://cloud.tencent.com/developer/article/1653676
454.四数相加II
class Solution {
public:
int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {
unordered_map<int,int> umap;
for(int a : nums1){
for(int b : nums2){
umap[a+b]++;
}
}
int count = 0;
for(int c : nums3){
for(int d : nums4){
// if (umap.find(0 - (c + d)) != umap.end()) {
// count += umap[0 - (c + d)];
// }
//int target=0-a-b;//
int target=0-c-d;
if(umap.find(target) != umap.end())//注意括号的位置
count += umap[target];
// if(umap.find(target != umap.end()))
// cout+=umap[target];
}
}
return count;
}
};
15. 三数之和
双指针法:
class Solution {
public:
vector<vector<int>> threeSum(vector<int>& nums) {
vector<vector<int>> result;
sort(nums.begin(),nums.end());
// 找出a + b + c = 0
// a = nums[i], b = nums[left], c = nums[right]
for(int i=0;i<nums.size();i++){
// 排序之后如果第一个元素已经大于零,那么无论如何组合都不可能凑成三元组,直接返回结果就可以了
if(nums[i] > 0) return result;
// 错误去重a方法,将会漏掉-1,-1,2 这种情况
/*
if (nums[i] == nums[i + 1]) {
continue;
}
*/
// 正确去重a方法
if(i > 0 && nums[i] == nums[i-1]) continue;
int left = i+1;
int right = nums.size()-1;
while(right > left){
// 去重复逻辑如果放在这里,0,0,0 的情况,可能直接导致 right<=left 了,从而漏掉了 0,0,0 这种三元组
/*
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
*/
if(nums[i] + nums[left] + nums[right]>0) right--;
else if(nums[i] + nums[left] + nums[right] < 0) left++;
else{
result.push_back(vector<int>{nums[i],nums[left],nums[right]});
//注意push.back() 里面vector初始化 是{},不是()
// 去重逻辑应该放在找到一个三元组之后,对b 和 c去重
if(right > left && nums[right] == nums[right-1]) right--;
else if(right > left && nums[left] == nums[left+1]) left++;
// 找到答案时,双指针同时收缩
right--;
left++;
}
}
}
return result;
}
};
18. 四数之和
双指针法:
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
vector<vector<int>> result;
sort(nums.begin(),nums.end());
for(int k = 0; k < nums.size(); k++){
// 剪枝处理
if(nums[k] > target && nums[k] > 0 && target > 0)
//if (nums[k] > target && nums[k] >= 0) //两种边界处理 都可以
return result;
// 剪枝处理
if(k > 0 && nums[k] == nums[k-1]) continue;
for(int i = k + 1; i < nums.size(); i++){
// 2级剪枝处理
if(nums[k] + nums[i] > target && nums[k] + nums[i] > 0 && target > 0)
//if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0)//两种边界处理 都可以
break;
// 对nums[i]去重
if(i > k + 1 && nums[i] == nums[i -1]) continue;
int left = i+1;
int right = nums.size()-1;
while(right > left){
// nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出
if((long)nums[k] + nums[i] + nums[left] + nums[right] > target) right--;
else if((long)nums[k] + nums[i] + nums[left] + nums[right] < target) left++;
else{
result.push_back(vector<int>{nums[k],nums[i],nums[left],nums[right]});//注意push.back() 里面vector初始化 是{},不是()
// 去重逻辑应该放在找到一个四元组之后,对b 和 c去重
// 对nums[left]和nums[right]去重
// if(right > left && nums[right] == nums[right-1]) right--;必须是while
// else if(right > left && nums[left] == nums[left+1]) left++;
while(right > left && nums[right] == nums[right-1]) right--;
while(right > left && nums[left] == nums[left+1]) left++;
// 找到答案时,双指针同时收缩
right--;
left++;
}
}
}
}
return result;
}
};
/*class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
vector<vector<int>> result;
sort(nums.begin(), nums.end());
for (int k = 0; k < nums.size(); k++) {
// 剪枝处理
if (nums[k] > target && nums[k] >= 0) {
break; // 这里使用break,统一通过最后的return返回
}
// 对nums[k]去重
if (k > 0 && nums[k] == nums[k - 1]) {
continue;
}
for (int i = k + 1; i < nums.size(); i++) {
// 2级剪枝处理
if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
break;
}
// 对nums[i]去重
if (i > k + 1 && nums[i] == nums[i - 1]) {
continue;
}
int left = i + 1;
int right = nums.size() - 1;
while (right > left) {
// nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出
if ((long) nums[k] + nums[i] + nums[left] + nums[right] > target) {
right--;
// nums[k] + nums[i] + nums[left] + nums[right] < target 会溢出
} else if ((long) nums[k] + nums[i] + nums[left] + nums[right] < target) {
left++;
} else {
result.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
// 对nums[left]和nums[right]去重
while (right > left && nums[right] == nums[right - 1]) right--;
while (right > left && nums[left] == nums[left + 1]) left++;
// 找到答案时,双指针同时收缩
right--;
left++;
}
}
}
}
return result;
}
};
*/