Leetcode_入门_哈希表
1、 数组中两个数的和为给定值（1、Easy）
1）题目要求
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
2）我的解法
c++
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target)
{
unordered_map<int,int> hash;
for(int i=0;i<nums.size();i++)
{
if(hash.count(target-nums[i])>0&&hash[target-nums[i]]!=i)return {hash[target-nums[i]],i};
hash[nums[i]]=i;
}
return {};
}
};
3）其他解法
排序+双指针法
这里先将数组排序好O（nlogn），再利用双指针法遍历一遍O（n）得到结果。
为了保存下标信息另开了一个数组
时间复杂度O（nlogn），空间复杂度O（n）
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target) {
vector<int> ans;
vector<int> temp;
temp=nums;
int n=temp.size();
sort(temp.begin(),temp.end());
int i=0,j=n-1;
while(i<j){
if(temp[i]+temp[j]>target)j--;
else if(temp[i]+temp[j]<target)i++;
else break;
}
if(i<j){
for(int k=0;k<n;k++){
if(i<n&&nums[k]==temp[i]){
ans.push_back(k);
i=n;
}
else if(j<n&&nums[k]==temp[j]){
ans.push_back(k);
j=n;
}
if(i==n&&j==n)return ans;
}
}
return ans;
}
};
作者：yun-yu-chen
链接： link
来源：力扣（LeetCode）
4）自己的优化代码
c++
class Solution {
public:
vector<int> twoSum(vector<int>& nums, int target)
{
unordered_map<int,int> hash;
for(int i=0;i<nums.size();i++)
{
if(hash.count(target-nums[i])>0&&hash[target-nums[i]]!=i)return {hash[target-nums[i]],i};
hash[nums[i]]=i;
}
return {};
}
};
5）学到的东西
c++:
unordered_map直接用[]操作
find()返回的是迭代器
count(key)返回的是对应key的value个数，但由于unordered_map中不能有重复元素，所以最大为1
2、 判断数组是否含有重复元素（217、Easy）
1）题目要求
给定一个整数数组，判断是否存在重复元素。
如果任意一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。
示例 1:
输入: [1,2,3,1]
输出: true
示例 2:
输入: [1,2,3,4]
输出: false
示例 3:
输入: [1,1,1,3,3,4,3,2,4,2]
输出: true
2）我的解法
c++
class Solution {
public:
bool containsDuplicate(vector<int>& nums) {
unordered_map<int,int> hash;
for(int i=0;i<nums.size();i++)
{
if(hash.count(nums[i])==1)return true;
else hash[nums[i]]=i;
}
return false;
}
};
3）其他解法
1.哈希，判断key值是否大于1
class Solution {
public:
bool containsDuplicate(vector<int>& nums) {
unordered_map <int,int>mp;
for(int i:nums)
{
mp[i]++; //i对应的value值++
if(mp[i]>1) return true; //i对应的value值大于1，则说明存在重复元素
}
return false;
}
};
2.利用集合，与原数组比较大小
class Solution {
public:
bool containsDuplicate(vector<int>& nums) {
return nums.size() > unordered_set<int>(nums.begin(), nums.end()).size();
//如果原数组的大小>集合的大小，则说明存在重复元素
}
};
3.排序，比较前后两个元素是否相等，来判断是否存在重复元素
class Solution {
public:
bool containsDuplicate(vector<int>& nums) {
sort(nums.begin(),nums.end());
for(int i=1;i<nums.size();i++)
{
if(nums[i]==nums[i-1])
return true;
}
return false;
}
};
作者：zrita
链接：link
来源：力扣（LeetCode）
4）自己的优化代码
c++
class Solution {
public:
bool containsDuplicate(vector<int>& nums) {
unordered_map<int,int> hash;
for(int i=0;i<nums.size();i++)
{
if(hash.count(nums[i])==1)return true;
else hash[nums[i]]=i;
}
return false;
}
};
5）学到的东西
unordered_set不允许有相同元素，unordered_map不允许有相同的key，遇到相同的会进行覆盖
set的key与value相同，map不同
3、最长和谐序列（594、Easy）
1）题目要求
和谐数组是指一个数组里元素的最大值和最小值之间的差别正好是1。
现在，给定一个整数数组，你需要在所有可能的子序列中找到最长的和谐子序列的长度。
示例 1:
输入: [1,3,2,2,5,2,3,7]
输出: 5
原因: 最长的和谐数组是：[3,2,2,2,3].
说明: 输入的数组长度最大不超过20,000.
2）我的解法
c++
class Solution {
public:
int findLHS(vector<int>& nums) {
vector<int> result;
unordered_map<int,int> hash;
int resize=0;
int i=0;
for(i=0;i<nums.size();i++)
{
if(hash.count(nums[i])==0)hash[nums[i]]=1;
else hash[nums[i]]++;
}
for(i=0;i<nums.size();i++)
{
if(hash.count(nums[i]+1)!=0)
{
if((hash[nums[i]]+hash[nums[i]+1])>resize)resize=hash[nums[i]]+hash[nums[i]+1];
}
}
return resize;
}
};
3）其他解法
方法二：哈希映射（与我的做法思路相同）
在方法一中，我们枚举了 x 后，遍历数组找出所有的 x 和 x + 1。我们也可以用一个哈希映射（HashMap）来存储每个数出现的次数，这样就能在 O(1)O(1) 的时间内得到 x 和 x + 1 出现的次数。
我们首先遍历一遍数组，得到哈希映射。随后遍历哈希映射，设当前遍历到的键值对为 (x, value)，那么我们就查询 x + 1 在哈希映射中对应的值，就得到了 x 和 x + 1 出现的次数。
public class Solution {
public int findLHS(int[] nums) {
HashMap < Integer, Integer > map = new HashMap < > ();
int res = 0;
for (int num: nums) {
map.put(num, map.getOrDefault(num, 0) + 1);
}
for (int key: map.keySet()) {
if (map.containsKey(key + 1))
res = Math.max(res, map.get(key) + map.get(key + 1));
}
return res;
}
}
方法三：哈希映射 + 单次扫描
在方法二中，我们需要对数组进行一次扫描，再对哈希映射进行一次扫描。事实上，我们也可以设计出只进行一次扫描的算法。
我们扫描一次数组，当扫描到元素 x 时，我们首先将 x 加入哈希映射，随后获取哈希映射中 x - 1, x, x + 1 三者出现的次数 u, v, w，那么 u + v 即为 x - 1, x 组成的和谐子序列的长度，v + w 即为 x, x + 1 组成的和谐子序列的长度。假设数组中最长的和谐子序列的最后一个元素在数组中的位置为 i，那么在扫描到 nums[i] 时，u + v 和 v + w 中一定有一个就是答案。因此这种方法可以找到最长的和谐子序列的长度。
public class Solution {
public int findLHS(int[] nums) {
HashMap < Integer, Integer > map = new HashMap < > ();
int res = 0;
for (int num: nums) {
map.put(num, map.getOrDefault(num, 0) + 1);
if (map.containsKey(num + 1))
res = Math.max(res, map.get(num) + map.get(num + 1));
if (map.containsKey(num - 1))
res = Math.max(res, map.get(num) + map.get(num - 1));
}
return res;
}
}
作者：LeetCode
链接：link
来源：力扣（LeetCode）
4）自己的优化代码
c++
class Solution {
public:
int findLHS(vector<int>& nums) {
vector<int> result;
unordered_map<int,int> hash;
int resize=0;
int i=0;
for(i=0;i<nums.size();i++)
{
hash[nums[i]]++;
if(hash.count(nums[i]+1)!=0)
{
resize=max(resize,hash[nums[i]]+hash[nums[i]+1]);
}
if(hash.count(nums[i]-1)!=0)
{
resize=max(resize,hash[nums[i]]+hash[nums[i]-1]);
}
}
return resize;
}
};
5）学到的东西
java知识：
getordefault()给不存在的键值提供默认值
Java中Map的getOrDefault()方法
C++知识：
即使key不存在，hash[key]默认为0
4、最长连续序列（128、Hard）
1）题目要求
给定一个未排序的整数数组，找出最长连续序列的长度。
要求算法的时间复杂度为 O(n)。
示例:
输入: [100, 4, 200, 1, 3, 2]
输出: 4
解释: 最长连续序列是 [1, 2, 3, 4]。它的长度为 4。
2）我的解法
class Solution {
public int longestConsecutive(int[] nums) {
Map<Integer,Integer> hash=new HashMap<>();
Map<Integer,Integer> result=new HashMap<>();
int max=0;
UFSet u=new UFSet(nums.length);
for(int i=0;i<nums.length;i++){
if(hash.containsKey(nums[i]))nums[i]=Integer.MIN_VALUE;
else hash.put(nums[i],i);
if(hash.containsKey(nums[i]-1))u.union(hash.get(nums[i]-1),i);
if(hash.containsKey(nums[i]+1))u.union(hash.get(nums[i]+1),i);
}
int tempRoot=0;
for(int i=0;i<nums.length;i++){
tempRoot=u.find(i);
if(!result.containsKey(tempRoot))result.put(tempRoot,1);
else result.put(tempRoot,result.get(tempRoot)+1);
max=Math.max(result.get(tempRoot),max);
}
return max;
}
}
class UFSet{
private int[] data;
public UFSet(int size){
data=new int[size];
for(int i=0;i<size;i++){
data[i]=i;
}
}
public int find(int i){
if(data[i]==i)return i;
data[i]=find(data[i]);
return data[i];
}
public boolean isConnected(int i,int j){
return find(i)==find(j);
}
public void union(int i,int j){
data[find(i)]=find(j);
}
}
3）其他解法
增加了判断跳过的逻辑之后，时间复杂度是多少呢？外层循环需要 O(n)的时间复杂度，只有当一个数是连续序列的第一个数的情况下才会进入内层循环，然后在内层循环中匹配连续序列中的数，因此数组中的每个数只会进入内层循环一次。根据上述分析可知，总时间复杂度为 O(n)，符合题目要求。
class Solution {
public int longestConsecutive(int[] nums) {
Set<Integer> num_set = new HashSet<Integer>();
for (int num : nums) {
num_set.add(num);
}
int longestStreak = 0;
for (int num : num_set) {
if (!num_set.contains(num - 1)) {
int currentNum = num;
int currentStreak = 1;
while (num_set.contains(currentNum + 1)) {
currentNum += 1;
currentStreak += 1;
}
longestStreak = Math.max(longestStreak, currentStreak);
}
}
return longestStreak;
}
}
该解也可以看作是并查集的特例
作者：LeetCode-Solution
链接：link
来源：力扣（LeetCode）
4）自己的优化代码
class Solution {
public int longestConsecutive(int[] nums) {
Set<Integer> hash=new HashSet<>();
int max=0;
int cur=1;
for(int i=0;i<nums.length;i++)hash.add(nums[i]);
for(int i=0;i<nums.length;i++){
if(hash.contains(nums[i]-1))continue;
cur=1;
while(hash.contains(nums[i]+cur)){//虽然两层循环，但时间复杂度为O(n)
//因为内外加起来最多2n次
cur++;
}
max=Math.max(max,cur);
}
return max;
}
}
5）学到的东西
并查集
哈希
扫一扫
231
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
