leetcode题解(查找表问题)
查找，是使用计算机处理问题时的一个最基本的任务，所以也是面试中很是常见的一类问题。不少算法问题的本质，就是要可以高效查找。学会使用系统库中的map和set，就已经成功了一半。c++
set的使用
两类查找问题
- 查找有无：元素’a’是否存在？set；集合
- 查找对应关系（键值对应）：元素’a’出现了几回？map；字典
- 一般语言的标准库中都内置set和map
- 容器类
- 屏蔽实现细节
- 了解语言中标准库里常见容器类的使用
常见操做：
- insert
- find
- erase:删除
- change (map)
leetcode349. 两个数组的交集
- 结果中每一个元素只能出现一次
- 出现的顺序能够是任意的
代码实现
// 349. Intersection of Two Arrays
// 时间复杂度：O(nlogn)
// 空间复杂度：O(n)
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
//O(nlogn)
set<int> record;
for( int i = 0 ; i < nums1.size() ; i ++ )
record.insert(nums1[i]);
//O(nlogn)
set<int> resultSet;
for( int i = 0 ; i < nums2.size() ; i ++ )
if( record.find( nums2[i] ) != record.end() )
resultSet.insert( nums2[i] );
//o(n)
vector<int> resultVector;
for(set<int>::iterator iter = resultSet.begin() ; iter != resultSet.end() ; iter ++ )
resultVector.push_back( *iter );
return resultVector;
}
};
改写程序:
// 349. Intersection of Two Arrays
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
set<int> record(nums1.begin(), nums1.end());
set<int> resultSet;
for( int i = 0 ; i < nums2.size() ; i ++ )
if( record.find( nums2[i] ) != record.end() )
resultSet.insert( nums2[i] );
return vector<int>(resultSet.begin(), resultSet.end());
}
};
复制代码
map的使用
leetcode350. 两个数组的交集 II
代码实现
// 350. Intersection of Two Arrays II
// 时间复杂度：O(nlogn)
// 空间复杂度：O(n)
class Solution {
public:
vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
map<int, int> record;
//O(nlogn)
for( int i = 0 ; i < nums1.size() ; i ++ )
record[nums1[i]] += 1;
//o(nlogn)
vector<int> resultVector;
for( int i = 0 ; i < nums2.size() ; i ++ )
if( record[ nums2[i] ] > 0 ){
resultVector.push_back( nums2[i] );
record[nums2[i]] --;
}
return resultVector;
}
};
复制代码
思考面试
- 数组有序如何改写？
set和map不一样底层实现的区别
常见操做：
-
insert算法
-
find数组
-
erasebash
-
change (map)微信
-
set和map能够有不一样的底层实现app
哈希表无论查找、插入、删除都是O(1)的时间复杂度。性能
- 哈希表的缺点是失去了数据的顺序性
数据的顺序性
-
数据集中的最大值和最小值ui
-
某个元素的前驱和后继spa
-
某个元素的floor和ceil
-
某个元素的排位rank
-
选择某个排位的元素select
-
map和set的底层实现为平衡二叉树
-
unordered_map和unordered_set的底层实现为哈希表
改用哈希表实现的代码
#include <unordered_set>
using namespace std;
// 349. Intersection of Two Arrays
// 时间复杂度：O(n)
// 空间复杂度：O(n)
class Solution {
public:
vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
// O(n)
unordered_set<int> record(nums1.begin(), nums1.end());
// O(n)
unordered_set<int> resultSet;
for( int i = 0 ; i < nums2.size() ; i ++ )
if( record.find( nums2[i] ) != record.end() )
resultSet.insert( nums2[i] );
// O(n)
return vector<int>(resultSet.begin(), resultSet.end());
}
};
//改写过使用hash表实现底层的unorder_map
#include <unordered_map>
using namespace std;
/// 350. Intersection of Two Arrays II
// 时间复杂度：O(n)
// 空间复杂度：O(n)
class Solution {
public:
vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
// O(n)
unordered_map<int, int> record;
for( int i = 0 ; i < nums1.size() ; i ++ )
record[nums1[i]] += 1;
// O(n)
vector<int> resultVector;
for( int i = 0 ; i < nums2.size() ; i ++ )
if( record[ nums2[i] ] > 0 ){
resultVector.push_back( nums2[i] );
record[nums2[i]] --;
}
// O(n)
return resultVector;
}
};
复制代码
类似题目
- leetcode242 Valid Anagram
Anagram：一个字符串中的字母调整顺序后与原字符串一致。
-
空串
-
字符集
-
leetcode202 Happy Number
判断一个数是否为happy number。happy number是指，一个数，将其替换为其各位数字的平方和，重复这个过程，若是最终能获得1，这是happy number，若是这个过程陷入了一个不包含1的循环，则不是happy number
判断一个数是否为happy number。以19为例：
1^2 + 9^2 = 82
8^2 + 2^2 = 68
6^2 + 8^2 = 100
1^2 + 0^2 + 0^2 = 1 Happy Number!
复制代码
- leetcode290 Word Pattern
给出一个模式（pattern）以及一个字符串，判断这个字符串是否符合模式？
如pattern=“abba”，str=“dog cat cat dog”，返回true
如pattern=“abba”，str=“dog cat cat fish”，返回false
字符集？
空串符合任意模式？仍是不符合任意模式？
复制代码
- leetcode205 Isomorphic Strings
判断两个字符串是否同构？
若是咱们可以寻找到一个字符集到字符集的映射，使得经过这个字符集的映射，s能够转变为t，则称为s和t同构。
如 egg 和 add，返回true
如 foo 和 bar，返回false
如 paper 和 title，返回true
复制代码
注意
-
字符集？
-
空串
-
是否能够一个字母映射到本身？
-
451 Sort Characters By Frequency
给定一个字符串，按照字母出现频率的倒序重组整个字符串
如“tree”，返回“eert”
如“cccaaa”，返回“cccaaa”
如“Aabb”，返回“bbAa”
对于相同频次的字母，顺序任意。大小写敏感。
复制代码
一个使用查找表的经典问题
leetcode1 两数之和
注意
- 索引从0开始计算仍是从1开始计算？
- 没有解怎么办？
- 有多个解怎么办？ 保证有惟一解
暴力解法：O(n^2)
- 遍历全部数据对。判断是否等于target。
双索引对撞
- 排序后，使用双索引对撞：O(nlogn) + O(n) = O(nlogn)
使用查找表
- 查找表。将全部元素放入查找表，以后对于每个元素a，查找 target - a 是否存在。存在的话索引是谁。
- 将全部元素放入查找表 - 不行
- 只把v前面的放入查找表
//时间复杂度:O(n)
//空间复杂度：O(n)
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
unordered_map<int,int> record;
for( int i = 0 ; i < nums.size() ; i ++ ){
int complement = target - nums[i];
if( record.find(complement) != record.end() ){
int res[] = {i, record[complement]};
return vector<int>(res, res + 2);
}
record[nums[i]] = i;
}
throw invalid_argument("the input has no solution");
}
};
复制代码
类似问题
leetcode15 3Sum
给出一个整形数组，寻找其中的全部不一样的三元组(a,b,c)，使得a+b+c=0
如 nums = [-1, 0, 1, 2, -1, -4]
结果为[ [-1, 0, 1], [-1,-1,2] ]
- 不一样的三元组？
- 若是有多个解，解的顺序？
- 若是没有解？
leetcode18 4Sum
给出一个整形数组，寻找其中的全部不一样的四元组(a,b,c,d)，使得a+b+c+d 等于一个给定的数字target。
如 nums = [1, 0, -1, 0, -2, 2]，target = 0
结果为[ [-1, 0, 0, 1], [-2, -1, 1, 2], [-2, 0, 0, 2] ]
leetcode16 3Sum Closest
给出一个整形数组，寻找其中的三个元素a,b,c，使得a+b+c的值最接近另一个给定的数字target
如 nums = [-1, 2, 1, -4]，target = 1
结果为2 ( -1 + 2 + 1 = 2 )
复制代码
注意
-
若是有多个解，其和target值的接近程度同样怎么办？
-
若是没解？（可不可能没解？）
灵活选择键值
leetcode454 4Sum II
暴力解法：O(n^4)
500^4 = 625,0000,0000
将D中的元素放入查找表：O(n^3)
500^3 = 1,2500,0000
将C+D的每一种可能放入查找表：O(n^2)
- 500^2 = 25,0000
- 要记录每一种和出现了多少次，因此使用map
代码实现：
//时间复杂度O(n^2)
//空间复杂度O(n^2)
class Solution {
public:
int fourSumCount(vector<int>& A, vector<int>& B, vector<int>& C, vector<int>& D) {
assert( A.size() == B.size() && B.size() == C.size() && C.size() == D.size() );
unordered_map<int,int> hashtable;
for( int i = 0 ; i < C.size() ; i ++ )
for( int j = 0 ; j < D.size() ; j ++ )
hashtable[C[i]+D[j]] += 1;
int res = 0;
for( int i = 0 ; i < A.size() ; i ++ )
for( int j = 0 ; j < B.size() ; j ++ )
if( hashtable.find(-A[i]-B[j]) != hashtable.end() )
res += hashtable[-A[i]-B[j]];
return res;
}
};
复制代码
思考
- 将A+B和C+D的每一种可能放入两个查找表：O(n^2)
类似问题
- leetcode49 Group Anagrams
给出一个字符串数组，将其中全部能够经过颠倒字符顺序产生相同结果的单词进行分组。
如 [ “eat”, “tea”, “tan”, “ate”, “nat”, “bat”]
返回[ [“ate”, “eat”, “tea”], [“nat”, “tan”], [“bat”] ]
复制代码
注意
- 字符集
- 大小写敏感
灵活选择键值2
leetcode447 回旋镖的数量(Number of Boomerangs)
暴力解法：O(n^3)
- 三重循环枚举全部的可能性。
使用查找表
- 观察到 i 是一个“枢纽”，对于每一个点i，遍历其他点到i的距离
- 对于每一个枢纽i,计算它到其它点j的距离,并将距离做为键存入map中，value为距离的个数。
- O(n^2)
//时间复杂度：O(n^2)
//空间复杂度：O(n)
class Solution {
public:
int numberOfBoomerangs(vector<pair<int, int>>& points) {
int res = 0;
for( int i = 0 ; i < points.size() ; i ++ ){
// record中存储 点i 到全部其余点的距离出现的频次
unordered_map<int, int> record;
for( int j = 0 ; j < points.size() ; j ++ )
if( j != i )
record[dis(points[i], points[j])] += 1;
for( unordered_map<int, int>::iterator iter = record.begin() ; iter != record.end() ; iter ++ )
res += (iter->second)*(iter->second-1);
}
return res;
}
private:
int dis( const pair<int,int> &pa, const pair<int,int> &pb){
return (pa.first - pb.first) * (pa.first - pb.first) +
(pa.second - pb.second) * (pa.second - pb.second);
}
};
复制代码
类似问题
leetcode149 Max Points on a Line
给出2D平面上的n个点，求出最多有多少个点在一条直线上？
- 点坐标的范围
- 点坐标的表示（整数？浮点数？浮点偏差？）
查找表和滑动窗口
暴力解法：O(n^2)
- 时间性能不知足
滑动窗口
- 结合使用滑动窗口和查找表，不断查找当前滑动窗口内有没有重复值。
// 时间复杂度: O(n)
// 空间复杂度: O(k)
class Solution {
public:
bool containsNearbyDuplicate(vector<int>& nums, int k) {
if( nums.size() <= 1 )
return false;
if( k <= 0 )
return false;
unordered_set<int> record;
for( int i = 0 ; i < nums.size() ; i ++ ){
if( record.find( nums[i] ) != record.end() )
return true;
record.insert( nums[i] );
// 保持record中最多有k个元素
// 由于在下一次循环中会添加一个新元素,使得总共考虑k+1个元素
if( record.size() == k + 1 )
//删除掉最左侧元素
record.erase( nums[i-k] );
}
return false;
}
};
复制代码
类似问题
- leetcode217 Contains Duplicate
给出一个整形数组，若数组中存在相同的元素，则返回true，不然返回false.
二分搜索树底层实现的顺序性
leetcode220. 存在重复元素 III
思想
维持滑动窗的大小为k 遍历每个元素，在活动窗口中寻找|v-nums[i]| < t， 即窗口中的元素范围为：[v-t...v+t]之间。采用ceil和floor能够实现
代码实现
// 时间复杂度: O(nlogn)
// 空间复杂度: O(k)
class Solution {
public:
bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
set<long long> record;
for( int i = 0 ; i < nums.size() ; i ++ ){
if( record.lower_bound( (long long)nums[i] - (long long)t ) != record.end() &&
*record.lower_bound( (long long)nums[i] - (long long)t ) <= (long long)nums[i] + (long long)t )
return true;
record.insert( nums[i] );
if( record.size() == k + 1 )
record.erase( nums[i-k] );
}
return false;
}
};
复制代码
-------------------------华丽的分割线--------------------
看完的朋友能够点个喜欢/关注，您的支持是对我最大的鼓励。
想了解更多，欢迎关注个人微信公众号：番茄技术小栈
相关文章
- 1. LeetCode -- 查找问题
- 2. 查找问题
- 3. LeetCode 题解记录 - 二分查找
- 4. python问题查找
- 5. 算法问题——（查找问题）
- 6. leetcode题解（数组问题）
- 7. [LeetCode解题]--TOP_K问题
- 8. Java heap space 问题查找
- 9. keepalived脑裂问题查找
- 10. HardFault_Handler问题查找方法
- 更多相关文章...
- • Markdown 标题 - Markdown 教程
- • jQuery Mobile 主题 - jQuery Mobile 教程
- • PHP Ajax 跨域问题最佳解决方案
- • 算法总结-二分查找法
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. LeetCode -- 查找问题
- 2. 查找问题
- 3. LeetCode 题解记录 - 二分查找
- 4. python问题查找
- 5. 算法问题——（查找问题）
- 6. leetcode题解（数组问题）
- 7. [LeetCode解题]--TOP_K问题
- 8. Java heap space 问题查找
- 9. keepalived脑裂问题查找
- 10. HardFault_Handler问题查找方法