大二第二周，刷下6+12道力扣（力扣+哈希）。

最新推荐文章于 2024-07-22 16:27:42 发布
最新推荐文章于 2024-07-22 16:27:42 发布
阅读量123 收藏
点赞数 3
分类专栏： 笔记 力扣 文章标签： leetcode c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60930189/article/details/120191485
版权

相信我，我会永远坚持下去的！

目录

第一题：两个数组的交集（力扣349）

第二题：有序数组的单一元素

第三题：特殊数组的特征值

第四题：两个数组间的距离值

第五题：寻找数组的中心下标

第六题：除自身以外数组的乘积

下面是哈希专题

1.设计哈希集合：

2.设计哈希映射

3.存在重复元素

4.只出现一次的数字

5.两个数组的交集

6.两数之和

7.同构字符串

8.两个列表的最小索引总和

9.字符串中的第一个唯一字符

10.两个数组的交集（II）

11.存在重复的元素

12.字母异位词分组 

第一题：两个数组的交集（力扣349）

题目链接：力扣349

解题代码：(双指针法，哈希表）

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
int length1=nums1.size();int length2=nums2.size();
        sort(nums1.begin(),nums1.end());
        sort(nums2.begin(),nums2.end());
        int index1=0;int index2=0;vector<int>arr;
        while(index1<=length1-1&&index2<=length2-1){
          if(nums1[index1]==nums2[index2])
          {
              if(!arr.size()||arr.back()!=nums1[index1]){
              arr.push_back(nums1[index1]);
              }
              index1++;
              continue;
          }
            else if(nums1[index1]>nums2[index2])index2++;
            else index1++;
        }
        return arr;
    }
};
class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int>hashset(nums1.begin(),nums1.end());
        unordered_set<int>result;
        for(int num:nums2){
            if(hashset.find(num)!=hashset.end())result.insert(num);
        }
        vector<int> res(result.begin(),result.end());
        return res;
    }
};

第二题：有序数组的单一元素

题目链接：力扣540

解题代码：

class Solution {
public:
    int singleNonDuplicate(vector<int>& nums) {
int left=0;int right=1;
     while(right<nums.size()){
         if(nums[left]==nums[right]){
             left+=2;
             right+=2;
         }
         else return nums[left];
     }
        return nums[nums.size()-1];
    }
};

第三题：特殊数组的特征值

题目链接：力扣1608

解题代码：

class Solution {
public:
    int specialArray(vector<int>& nums) {
sort(nums.rbegin(),nums.rend());
    nums.push_back(0);
        for(int i=0;i<nums.size();i++){
            if(nums[i]<i&&nums[i-1]>=i)return i;
        }
        return -1;
    }
};

第四题：两个数组间的距离值

题目链接：力扣1385

解题代码：

class Solution {
public:
    int findTheDistanceValue(vector<int>& arr1, vector<int>& arr2, int d) {
        int result=0;
for(int i=0;i<arr1.size();i++){
    int cnt=0;
    
    for(int j=0;j<arr2.size();j++){
        if(arr1[i]-arr2[j]>d||arr1[i]-arr2[j]<-d)++cnt;
        else break;
    }
    if(cnt==arr2.size())++result;
}
        return result;
    }
};

第五题：寻找数组的中心下标

题目链接：力扣724

解题代码：

class Solution {
public:
    int pivotIndex(vector<int>& nums) {
long total=accumulate(nums.begin(),nums.end(),0);
        long sum=0;
        for(int i=0;i<nums.size();i++){
            if(2*sum+nums[i]==total)return i;
            else sum+=nums[i];
        }
        return -1;
    }
};

第六题：除自身以外数组的乘积

题目链接：力扣238

解题代码：

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int n=nums.size();
        vector<int>left(n,0);vector<int>right(n,0);
        vector<int>answer(n,0);
        left[0]=1;right[n-1]=1;
        for(int i=1;i<n;i++){
            left[i]=left[i-1]*nums[i-1];
        }
        for(int i=n-2;i>=0;i--){
            right[i]=right[i+1]*nums[i+1];
        }
        for(int i=0;i<n;i++){
            answer[i]=left[i]*right[i];
        }
        return answer;
    }
};

下面是哈希专题

1.设计哈希集合：

题目链接：力扣705

解题代码：

#define MAXSIZE 10000
class MyHashSet {
    private:
    vector<int>set1[MAXSIZE];
    int GetIndex(int number){
        return number%MAXSIZE;
    }
    int GetPos(int number,int index){
        for(int i=0;i<set1[index].size();i++){
            if(number==set1[index][i])return i;
        }
        return -1;
    }
public:
    /** Initialize your data structure here. */
    MyHashSet() {

    }
    
    void add(int key) {
int index=GetIndex(key);
if(GetPos(key,index)==-1)set1[index].push_back(key);
    }
    
    void remove(int key) {
int index=GetIndex(key);
int pos=GetPos(key,index);
        if(pos!=-1){
        set1[index].erase(set1[index].begin()+pos);
    }
    }
    /** Returns true if this set contains the specified element */
    bool contains(int key) {
int index=GetIndex(key);
        if(GetPos(key,index)==-1)return false;
        else return true;
    }
};

/**
 * Your MyHashSet object will be instantiated and called as such:
 * MyHashSet* obj = new MyHashSet();
 * obj->add(key);
 * obj->remove(key);
 * bool param_3 = obj->contains(key);
 */

2.设计哈希映射

题目链接：力扣706

解题代码：

#define MAX_LEN 10000
class MyHashMap {
private:
vector<pair<int,int>>map[MAX_LEN];
    int GetIndex(int key){
        return key%MAX_LEN;
    }
    int GetPos(int key,int index){
        for(int i=0;i<map[index].size();i++){
            if(map[index][i].first==key)return i;
        }
        return -1;
    }
public:
    /** Initialize your data structure here. */
    MyHashMap() {

    }
    
    /** value will always be non-negative. */
    void put(int key, int value) {
int index=GetIndex(key);
        int pos=GetPos(key,index);
        if(pos==-1){
            map[index].push_back(make_pair(key,value));
        }
        else {
            map[index][pos].second=value;
        }
    }
    
    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
    int get(int key) {
int index=GetIndex(key);
        int pos=GetPos(key,index);
        if(pos==-1)return -1;
        else return map[index][pos].second;
    }
    
    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
    void remove(int key) {
int index=GetIndex(key);
        int pos=GetPos(key,index);
        if(pos==-1)return;
        else {
            map[index].erase(map[index].begin()+pos);
        }
    }
};

/**
 * Your MyHashMap object will be instantiated and called as such:
 * MyHashMap* obj = new MyHashMap();
 * obj->put(key,value);
 * int param_2 = obj->get(key);
 * obj->remove(key);
 */

3.存在重复元素

题目链接：力扣217

解题代码：

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
sort(nums.begin(),nums.end());
        for(int i=0;i<nums.size()-1;i++){
            if(nums[i]==nums[i+1])return true;
        }
        return false;
    }
};

4.只出现一次的数字

题目链接：力扣136

解题代码：

class Solution {
public:
    int singleNumber(vector<int>& nums) {
int result=nums[0];
        for(int i=1;i<nums.size();i++){
          result=result^nums[i];  
        }
        return result;
        
    }
};

5.两个数组的交集

题目链接：力扣349

解题代码：

class Solution {
public:
    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {
        unordered_set<int>hashset(nums1.begin(),nums1.end());
        unordered_set<int>result;
        for(int num:nums2){
            if(hashset.find(num)!=hashset.end())result.insert(num);
        }
        vector<int> res(result.begin(),result.end());
        return res;
    }
};

6.两数之和

题目链接：力扣1   ​​​​​​   ​​​​​​

解题代码：

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int,int>hashmap;
        for(int i=0;i<nums.size();i++){
            auto it=hashmap.find(target-nums[i]);
            if(it!=hashmap.end())return{i,it->second};
            else hashmap[nums[i]]=i;
        }
        return {};
    }
};

7.同构字符串

题目链接：力扣205 

解题代码：

class Solution {
public:
    bool isIsomorphic(string s, string t) {
unordered_map<char,char>hashmap;
unordered_map<char,char>t2s;
        for(int i=0;i<s.size();i++){
            auto it=hashmap.find(s[i]);
            if(it!=hashmap.end()){
                if(hashmap[s[i]]!=t[i])return false;
            }
            else hashmap[s[i]]=t[i];
        }
        for(int i=0;i<t.size();i++){
            auto it=t2s.find(t[i]);
            if(it!=t2s.end()){
                if(t2s[t[i]]!=s[i])return false;
            }
            else t2s[t[i]]=s[i];
        }
        return true;
    }
};

8.两个列表的最小索引总和

题目链接：力扣599  

解题代码：

class Solution {
public:
    vector<string> findRestaurant(vector<string>& list1, vector<string>& list2) {
unordered_map<string,int>hashmap;
        vector<pair<int,string>>res;
        for(int i=0;i<list1.size();i++){
            hashmap[list1[i]]=i;
        }
        for(int i=0;i<list2.size();i++){
            auto it=hashmap.find(list2[i]);
            if(it!=hashmap.end())res.push_back(make_pair(i+hashmap[list2[i]],list2[i]));
        }
        int index=0;
        for(int i=1;i<res.size();i++){
            if(res[i].first<res[index].first)index=i;
        }
        vector<string>result;
        for(int i=0;i<res.size();i++){
            if(res[i].first==res[index].first)result.push_back(res[i].second);
        }
        return result;
    }
};

9.字符串中的第一个唯一字符

题目链接：力扣387

解题代码：

class Solution {
public:
    int firstUniqChar(string s) {
unordered_map<char,int>hashmap;
        for(int i=0;i<s.size();i++){
            auto it=hashmap.find(s[i]);
            if(it!=hashmap.end())++hashmap[s[i]];
            else hashmap[s[i]]=1;
        }
        for(int i=0;i<s.size();i++){
            if(hashmap[s[i]]==1)return i;
        }
        return -1;
    }
};

10.两个数组的交集（II）

题目链接：力扣350

解题代码：

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
unordered_map<int,int>hashmap;
        vector<int>result;
        for(int i=0;i<nums1.size();i++){
            hashmap[nums1[i]]++;
        }
        for(int i=0;i<nums2.size();i++){
            auto it=hashmap.find(nums2[i]);
            if(it!=hashmap.end()){
                if(hashmap[nums2[i]]>0){result.push_back(nums2[i]);
            --hashmap[nums2[i]];
                                        }
            }
        }
        return result;
    }
};

11.存在重复的元素

题目链接：力扣219

解题代码：

class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
unordered_map<int,int>hashmap;
    for(int i=0;i<nums.size();i++){
        auto it=hashmap.find(nums[i]);
        if(it!=hashmap.end()){
            if(i-hashmap[nums[i]]<=k)return true;
            
        }
         hashmap[nums[i]]=i;
    }
        return false;
        
    }
};

12.字母异位词分组 

题目链接：力扣49

解题代码：

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string,vector<string>>hashmap;
        for(int i=0;i<strs.size();i++){
            string key=strs[i];
            sort(key.begin(),key.end());
            hashmap[key].push_back(strs[i]);
        }
        vector<vector<string>>ans;
        for(auto it=hashmap.begin();it!=hashmap.end();it++){
            ans.push_back(it->second);
        }
        return ans;
    }
    
};

已知乾坤大，犹怜草木青。这里北风，星河辽阔，一路相伴！

流水亦有情@
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
力扣刷题百天计划 Day12 环形链表 力扣题库第141题 C# 哈希表+双指针
m0_48781656的博客
01-24 163
学习目标： 我会持续更新我独特的算法思路，希望能给大家带来不一样的思维拓展！ 如果大家感觉有帮助的话，欢迎点赞关注支持哦！ 你们的鼓励是我坚持下去的动力！ ！！！ 力扣题库第141题 官方链接 学习内容： 环形链表 给你一个链表的头节点 head ，判断链表中是否有环。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注
【力扣刷题】数组-链表-哈希-双指针
06-21
"数组-链表-哈希-双指针" 在计算机科学中，数组是一种基本的数据结构，用于存储相同类型的数据元素。数组中的每个元素都可以通过下标索引来访问，下标从0开始计数。数组的元素是不能删除的，只能覆盖。不能释放单个...
leetcode--473. 火柴拼正方形
简单记录一下
07-27 411
还记得童话《卖火柴的小女孩》吗？现在，你知道小女孩有多少根火柴，请找出一种能使用所有火柴拼成一个正方形的方法。不能折断火柴，可以把火柴连接起来，并且每根火柴都要用到。 输入为小女孩拥有火柴的数目，每根火柴用其长度表示。输出即为是否能用所有的火柴拼成正方形。 示例 1: 输入: [1,1,2,2,2] 输出: true 解释: 能拼成一个边长为2的正方形，每边两根火柴。 示例 2: 输入: [3,3...
滑动窗口+哈希-力扣3
blank_koko的博客
08-17 69
给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
力扣(LeetCode)刷题，简单+中等题(第31期)
不脱发的程序猿
02-03 1万+
力扣(LeetCode)定期刷题，每期10道题，业务繁重的同志可以看看我分享的思路，不是最高效解决方案，只求互相提升。
力扣(LeetCode)刷题，简单+中等题(第32期)
热门推荐
不脱发的程序猿
03-05 1万+
力扣(LeetCode)定期刷题，每期10道题，业务繁重的同志可以看看我分享的思路，不是最高效解决方案，只求互相提升。
力扣周赛，滑动窗口＋哈希
xiaoyuuanhou111的博客
11-07 93
滑动窗口，哈希
力扣专题----哈希表
weixin_45055431的博客
12-08 362
算法笔记-哈希表
力扣692. 前K个高频单词（哈希+小顶堆）
小麦China的博客
04-16 220
力扣692. 前K个高频单词（哈希+小顶堆） https://leetcode-cn.com/problems/top-k-frequent-words/ 哈希记录次数 建立list，排序，形成小顶堆 输出前k个 几个注意的点： 1、迭代器的使用：C++迭代器（STL迭代器）iterator详解 正向：vector<pair<string, int>>::iterator it=sorted_list.begin();it!=sorted_list.end();it+
力扣LeetCode-哈希表
weixin_56005963的博客
02-16 338
哈希表 一、基本知识点 1. 定义 哈希表是根据关键码的值而直接进行访问的数据结构。 2. 解决问题 快速判断一个元素是否出现集合里。 3. 哈希碰撞解决方法 拉链法与线性探测法。 4. 常见的三种哈希结构 数组 set（集合） map（映射） 集合 底层实现 是否有序 数值是否可以重复 能否更改数值 查询效率 增删效率 std::set 红黑树 有序 否 否 O(logn) O(
力扣刷题力扣刷题力扣刷题力扣刷题
07-16
- 搜索：深度优先搜索（DFS）、广度优先搜索（BFS）、二分查找、哈希查找等。 - 动态规划：解决最优化问题，例如斐波那契数列、背包问题、最长公共子序列等。 - 贪心算法：局部最优解来达到全局最优解，如活动...
Leetcode：力扣个人代码C ++
02-18
- **查找算法**：二分查找、哈希表查找等，C++的高效内存管理和运算速度使其在查找操作中表现出色。 - **图和树结构**：C++可以轻松创建和操作二叉树、AVL树、红黑树、图等数据结构，用于解决复杂的问题。 - **...
力扣-LeetCode全套2000题目解答C++和Java版.rar
06-26
这个压缩包文件包含的是LeetCode上2000道编程题目的C++和Java解法，覆盖了从第1题到第2000题的广泛范围。这些题目涵盖了数据结构、算法、设计模式等多个IT领域的核心知识点，是提升编程技术的宝贵资源。 首先，让...
js代码-力扣第六题
07-16
6. **二分查找**：当处理已排序的数组时，二分查找可以极大地提高查找效率。 7. **栈与队列**：这两种数据结构在处理问题如括号匹配、最近出现的最大值等问题时十分有效。 8. **贪心算法**：对于部分最优解的问题...
力扣 102题 二叉树的层次遍历 记录
最新发布
m0_49800270的博客
07-22 372
队列是一种先进先出（FIFO）的数据结构，非常适合于层序遍历，因为我们总是希望按照从树的上层到下层的顺序处理节点。队列操作：使用一个队列来管理待处理的树节点。队列的先进先出特性保证了树的每一层都按照从左到右的顺序被处理。
stack(leetcode练习题,牛客)
2301_81692739的博客
07-19 403
最开始写的，总会有一些样例过不了，没考虑全，后来看题解上的方法，将下标压入栈中，用右括号的下标减去栈顶下标，就是有效长度。不然只顾着最长，反而无法得到正确的有效长度。一个完整的括号，要么是1，要么里边包含其他括号，进行了 *2。所以，可以每遇到一个右括号，进行一次运算，第一次为 1，以后每次乘二，累加到栈顶。遇到左括号，就向栈压入0，重新运算，当遇到右括号，再弹出.如果数字比栈顶小就压入，否则，将栈顶删除直到，比栈顶小或这栈为空。关于stack的知识，可以看点击查看上面的博客，以下题目全在。
【LeetCode】分隔链表
qq_26521261的博客
07-20 386
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 331
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
力扣刷题：掌握数组、链表、哈希与双指针技巧
在IT编程领域，数组、链表、哈希表和双指针技巧是基础且重要的概念，尤其在算法设计和数据结构的学习中。本文将分别探讨这些主题。 **数组**： 数组是一种线性数据结构，它将具有相同类型的元素存储在连续的内存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值