哈希表理论基础
当我们遇到了要快速判断一个元素是否出现集合里的时候，就要考虑哈希法。
哈希碰撞解决办法：拉链法 线性探测法
常见哈希结构：数组 set map
使用集合来解决哈希问题的时候，优先使用unordered_set，因为它的查询和增删效率是最优的，如果需要集合是有序的，那么就用set，如果要求不仅有序还要有重复数据的话，那么就用multiset
哈希法是牺牲了空间换取了时间，因为我们要使用额外的数组，set或者是map来存放数据，才能实现快速的查找。
统计字符：
set统计字符是否出现过
map统计字符出现了几次
字符可重复出现multi
不需要统计字符出现顺序unordered
注意要点:
set map是红黑树，没有push_back push_front, 只有insert
set和map的find返回的是迭代器，有没有找到通过返回的迭代器是否是end
242.有效的字母异位词
思路：无序 需要统计字符出现了几次 用unordered_map
bool isAnagram(string s, string t) {
if(s.size() != t.size()) return false;
unordered_map<char, int> charMap;
for(int i = 0; i < s.size(); ++i)
charMap[s[i]]++;
for(int i = 0; i < t.size(); ++i)
{
if(charMap.find(t[i]) == charMap.end())
return false;
charMap[t[i]]--;
}
for(auto& it:charMap)
{
if(it.second != 0)
return false;
}
return true;
}349. 两个数组的交集
思考：不需要统计次数，用set，不需要排序用unordered，选择unordered_set
注意先将nums1转为unordered_set，再遍历nums2在nums1的树中查找，找到了将nums存在另一个unordered_set中，最后将unordered_set转为vector
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
unordered_set<int> NumSet;
unordered_set<int> MySet;
for(int i = 0; i < nums1.size(); ++i)
{
NumSet.insert(nums1[i]);
}
for(int j = 0; j < nums2.size(); ++j)
{
if(NumSet.find(nums2[j]) != NumSet.end())
MySet.insert(nums2[j]);
}
vector<int> res(MySet.begin(), MySet.end());
return res;
}第202题. 快乐数
思路：
给定数据n求sum
while(n != 0)
{
int tmp = n - 10*(n/10);
sum += tmp * tmp;
n = n/10;
}用无重复数不须排序不用记录出现次数的unordered_set res_set记录计算过的sum
不停地循环while(1), 如果出现sum = 1，返回true。res_set中出现了重复的sum，说明出现死循环了，返回false.
代码：
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;
}
}
};1. 两数之和
思路：
用target减掉num1，再在nums里找到有没有对应的nums2，快速在一个集合里找数据，用哈希表
不用排序，优先选用unordered，nums里有重复的元素，但是不能重复选取，可以用map计数
代码：
vector<int> twoSum(vector<int>& nums, int target) {
vector<int> res;
unordered_map<int, int> count_map; // 记录搜索的数据和下标，key为数据，value为下标
for(int i = 0; i < nums.size(); ++i)
{
count_map[nums[i]] = i;
}
for(int i = 0; i < nums.size(); ++i)
{
int find_num = target - nums[i];
auto find_it = count_map.find(find_num);
if(find_it == count_map.end()) continue; // count_map没找到目标值
if(i == find_it->second) continue; // 同一个元素不能使用两次
res.push_back(i);
res.push_back(find_it->second);
return res;
}
return res;
}注意：
auto find_it = count_map.find(find_num);
需要引用（例如，为了避免在后续代码中多次解引用迭代器），可以使用常量引用，因为不打算修改迭代器指向的内容：
const auto& find_it = count_map.find(find_num);
这里返回的find_it是迭代器指针。
回溯法：回溯法是暴力搜索，效率低
class Solution {
public:
vector<int> path;
vector<int> res; // 题目假设了只有一种答案
int sum = 0;
void backtracing(vector<int>& nums, int target, int startIndex)
{
if(sum == target && path.size() == 2)
{
res = path;
return;
}
if(path.size() >= 2) return; // 两数相加
for(int i = startIndex; i < nums.size(); ++i)
{
sum += nums[i];
path.push_back(i);
backtracing(nums, target, i + 1);
sum -= nums[i];
path.pop_back();
}
}
vector<int> twoSum(vector<int>& nums, int target) {
backtracing(nums, target, 0);
return res;
}
};第454题.四数相加II
class Solution {
public:
int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
unordered_map<int, int> umap; //key:a+b的数值，value:a+b数值出现的次数
// 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中
for (int a : A) {
for (int b : B) {
umap[a + b]++;
}
}
int count = 0; // 统计a+b+c+d = 0 出现的次数
// 再遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就把map中key对应的value也就是出现次数统计出来。
for (int c : C) {
for (int d : D) {
if (umap.find(0 - (c + d)) != umap.end()) {
count += umap[0 - (c + d)];
}
}
}
return count;
}
};注意：umap中a + b= 0 - (c + d)的组合可能有多个，所以count += umap[0 - (c + d)]
383. 赎金信
思路：
① unordered_map
将magazine字符转为unordered_map, key为字符，value为出现次数
在unordered_map中find ransom 的字符 然后value--
bool canConstruct(string ransomNote, string magazine) {
unordered_map<char, int> letter_map;
for(int i = 0; i < magazine.size();++i)
{
letter_map[magazine[i]]++;
}
for(int i = 0; i < ransomNote.size();++i)
{
auto it = letter_map.find(ransomNote[i]);
if(it == letter_map.end() || letter_map[ransomNote[i]] <= 0) return false;
letter_map[ransomNote[i]]--;
}
return true;
}class Solution {
public:
bool canConstruct(string ransomNote, string magazine) {
int record[26] = {0};
//add
if (ransomNote.size() > magazine.size()) {
return false;
}
for (int i = 0; i < magazine.length(); i++) {
// 通过record数据记录 magazine里各个字符出现次数
record[magazine[i]-'a'] ++;
}
for (int j = 0; j < ransomNote.length(); j++) {
// 遍历ransomNote，在record里对应的字符个数做--操作
record[ransomNote[j]-'a']--;
// 如果小于零说明ransomNote里出现的字符，magazine没有
if(record[ransomNote[j]-'a'] < 0) {
return false;
}
}
return true;
}
};第15题. 三数之和
思路：
先排序，i遍历，left是i下一个，right是最右
sum = i + left + right
sum>0 right左移，sum < 0 left右移， sum = 0 是一组三元组
！！！重点是去重
i去重：
nums[i] == nums[i - 1] continue;
为什么是i和i-1 ：向前比较，i元素不重复取
不是i 和i+1：向后比较，i和left不重复
left去重：while(nums[left] == nums[left + 1]) left++;
right去重：while(nums[right] == nums[right+ 1]) right--;
代码：
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;
}
};
第18题. 四数之和
这里四元组不重复表示取过的数不能再取，但是四元组内部可以有相等的值
先排序
对固定位置i和j的操作：和
代码：
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;
}
};
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
