算法 on acye's blog

力扣hot100(精讲)

Wed, 01 Apr 2026 01:00:00 +0000

说明

我这里写个是为了做一下整理
我觉得有趣，如果开发累了，可以换一换脑子
注：题目可直抵题目，所以不写题目内容

题目讲解

哈希：快速映射和快速查找

两数之和

暴力法暴力法就是遍历所有数，然后两两相加，如果和等于目标值，则返回结果，否则返回-1

class Solution {
public:
    vector<int> twoSum(std::vector<int>& nums, int target) {
        int n = nums.size();
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (nums[i] + nums[j] == target) {
                    return {i, j};
                }
            }
        }
        return {};
    }
};

哈希表

哈希表就是将数组中的数作为键，索引作为值，然后遍历数组，将每个数作为键，索引作为值，如果哈希表中存在目标值，则返回结果，否则返回-1
时间复杂度：O(n) 为什么可以优化时间呢？

因为哈希表的查找时间杂度是 O(1)，而数组的查找时间复杂度是 O(n)，所以哈希表可以提高查找效率。

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

字母异位词分组

思路：哈希表，将字符串排序，作为键，将原字符串作为值，然后遍历字符串，将排序后的字符串作为键，将原字符串作为值，如果哈希表中存在目标值，则返回结果，否则返回-1
时间复杂度：O(n)

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string,vector<string>>m;
        for(string& s:strs){
            string s1=s;
            sort(s1.begin(),s1.end());
            m[s1].push_back(s);
        }

        vector<vector<string>>ans;
        ans.reserve(m.size());
        for(auto & [x,value]:m){
            ans.push_back(value);
        }
        return ans;
    }
};

####最长连续序列

class Solution {
    public:
    int longestConsecutive(vector<int>& nums) {
        unordered_set<int>st(nums.begin(),nums.end());
        int ans=0;
        for(int x:st){
            if(!st.count(x-1)){
                continue;
            }
            int now=x;
            int cnt=1;
            while(st.count(now+1)){
                now++；
                cnt++;
            }
            ans=max(ans,cnt);
        }
        return ans;
    }
}

双指针

移动零

思路：双指针，一个指针指向当前位置，一个指针指向下一个位置，如果当前位置为0，则将下一个位置的值赋给当前位置，然后将下一个位置指针后移一位，直到下一个位置为0，然后将当前位置指针后移一位，直到数组末尾

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int l=0,r=1;
        if(nums.size()==1) return;
        while(r<nums.size()){
            if(nums[l]!=0){
                l++;
            }
            if(nums[l]==0){
                if(nums[r]!=0){
                    swap(nums[l],nums[r]);
                    l++;
                }
            }
            r++;
        }
    }
};

盛最多水的容器

class Solution {
public:
    int maxArea(vector<int>& height) {
        int l=0,r=height.size()-1;
        int ans=0;
        while(l<r){
            if(height[l]>=height[r]){
                ans=max(ans,height[r]*(r-l));
                r--;
            }
            else{
                ans=max(ans,height[l]*(r-l));
                l++;
            }
        }
        return ans;
    }
};

三数之和

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>>ans;
        int n=nums.size();
        sort(nums.begin(),nums.end());
        for(int i=0;i<n;i++){
            if(nums[i]>0) break;
            if(i>0&&nums[i]==nums[i-1]) continue;
            int l=i+1,r=n-1;
            while(l<r){
                int sum=nums[i]+nums[l]+nums[r];
                if(sum==0){
                    ans.push_back({nums[i],nums[l],nums[r]});
                    while(l<r&&nums[l]==nums[l+1]) l++;
                    while(l<r&&nums[r]==nums[r-1]) r--;
                    l++,r--;
                }
                else if(sum>0) r--;
                else l++;
            }
        }
        return ans;
    }
};

####接雨水

class Solution {
public:
    int trap(vector<int>& height) {
        int lmax=0,rmax=0;
        int l=0,r=height.size()-1;
        int n=height.size();
        int ans=0;
        while(l<r){
            lmax=max(lmax,height[l]);
            rmax=max(rmax,height[r]);
            if(lmax>rmax) {
                ans+=rmax-height[r];
                r--;
            }
            else{
                ans+=lmax-height[l];
                l++;
            }
        }
        return ans;
    }
};

###滑动窗口

无重复字符的最长子串

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int l=0;
        unordered_map<char,int>mp;
        int ans=0;
        for(int i=0;i<s.length();i++){
            char c=s[i];
            mp[c]++;
            while(mp[c]>1){
                mp[s[l]]--;
                l++;
            }
            ans=max(ans,i-l+1);
        }
        return ans;
    }
};

力扣hot150(精讲)

Fri, 28 Nov 2025 08:36:00 +0000

说明

我这里写个是为了做一下整理
我觉得有趣，如果开发累了，可以换一换脑子
注：题目可直抵题目，所以不写题目内容

题目讲解

两数之和

哈哈哈,虽然这是讲 hot150,但是这道题还是要说说的

暴力法暴力法就是遍历所有数，然后两两相加，如果和等于目标值，则返回结果，否则返回-1

class Solution {
public:
    vector<int> twoSum(std::vector<int>& nums, int target) {
        int n = nums.size();
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (nums[i] + nums[j] == target) {
                    return {i, j};
                }
            }
        }
        return {};
    }
};

哈希表

哈希表就是将数组中的数作为键，索引作为值，然后遍历数组，将每个数作为键，索引作为值，如果哈希表中存在目标值，则返回结果，否则返回-1
时间复杂度：O(n) 为什么可以优化时间呢？

因为哈希表的查找时间杂度是 O(1)，而数组的查找时间复杂度是 O(n)，所以哈希表可以提高查找效率。

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

删除有序数组中的重复项

这里将 I 和 II 的解法都给出，并给出过程

题目 I

我的想法是这样的，没什么好说的，stl 大法好

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        nums.erase(unique(nums.begin(),nums.end()),nums.end());
        return nums.size();
    }
};

如果不能用呢？用快慢指针，慢指针最后的位置就是去重后的数组长度，可以优化空间复杂度~~虽然空间不值钱~~

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int k=0;
        for(int i=0;i<nums.size();i++){
            if(nums[i]!=nums[k]){
                k++;
                nums[k]=nums[i];
            }
        }
        return k+1;//从0开始计数
    }
};

题目 II

我的思路：遍历数组，判断当前元素是否和前两个元素相同，相同则跳过，不同则赋给下一个位置~~好像也是双指针~~

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n=nums.size();
        if(n<=2) return n;
        int j=2;
        for(int i=2;i<n;i++){
            if(nums[i]!=nums[j-2]){
                nums[j]=nums[i];
                j++;
            }
        //相同则跳过
        }
    return j;
    }
};

双指针思路：同一的快慢指针思路，只是判断条件不同 O(n)

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n=nums.size();
        if(n<=2) return n;
        int j=0;
        int cnt=1;
        for(int i=1;i<n;i++){
            if(nums[i]==nums[j]){
                if(cnt>=2) continue;
                cnt++;
                j++;
                nums[j]=nums[i];
            }
            else{
                cnt=1;
                j++;
                nums[j]=nums[i];
            }
        }
        return j+1;
    }
};

O(1) 时间插入、删除和获取随机元素

说实话我不会，这是我想的，算暴力吧

class RandomizedSet {
public:
    RandomizedSet() {
        srand(time(0));
    }
    int find(int val){
        for(int i = 0; i < a.size(); i++){
            if (a[i] == val){
                return i;
            }
        }
        return -1;
    }
    bool insert(int val) {
        int loc=find(val);
        if(loc==-1){
            a.push_back(val);
            return 1;
        }
        return 0;
    }
    
    bool remove(int val) {
        int loc=find(val);
        if(loc==-1) return 0;
        else{
            a.erase(a.begin()+loc);
            return 1;
        }
    }
    int getRandom() {
        if(a.size()==0) return 0;
        return a[rand()%a.size()];
    }
    public:
    vector<int>a;
};

过了好一段时间，才想到的哈希

class RandomizedSet {
public:
    unordered_map<int, int> mp; 
    vector<int> a; 
    RandomizedSet() {
        srand(time(0)); 
    }

    int find(int val) {
        if (mp.count(val)) { 
            return mp[val];
        }
        return -1;
    }

    bool insert(int val) {
        if (find(val) != -1) {
            return false;
        }
        a.push_back(val);
        mp[val] = a.size() - 1; //这两步写完，才算完成。
        return true;
    }

    bool remove(int val) {
        int loc = find(val);
        if (loc == -1) {
            return false;
        }

        int last = a.back(); 
        a[loc] = last; 
        mp[last] = loc; 
        
        mp.erase(val);
        a.pop_back();
        return true;
    }

    int getRandom() {
        if (a.empty()) return 0;
        return a[rand() % a.size()];
    }
};

讲解一下remove()方法(不太好想)

先明确两个前提：

数组a的特点：尾部增删元素（push_back/pop_back）是 O (1) 时间，但中间删除元素（erase）是 O (n) 时间（因为后面的元素要整体前移）。
哈希表mp的作用：记录 “元素值→数组索引”，比如mp[3]=2表示元素 3 在数组a的索引 2 位置。你可能觉得 “元素要相连才合理”，但的核心需求是：插入 / 删除 / 随机访问都是 O (1)；元素不重复。它不要求元素保持任何顺序，所以哪怕用 “八竿子打不着的最后一个元素” 替换，只要最终删掉了目标元素，且哈希表映射正确，就完全符合要求。
其实你想想这是一个误区，数组的顺序反而不重要

接雨水

网红题目,不必多言~~据说字节的扫地阿姨都会做~~
我的思路：~~其实我不理解为什么说难~~看一个柱子能接多少水，应该就能想到贪心+双指针/单调栈

class Solution {
public:
    int trap(vector<int>& height) {
        int lmax=0,rmax=0;
        int l=0,r=height.size()-1;
        int n=height.size();
        int ans=0;
        while(l<r){
            lmax=max(lmax,height[l]);
            rmax=max(rmax,height[r]);
            if(lmax>rmax) {
                ans+=rmax-height[r];
                r--;
            }
            else{
                ans+=lmax-height[l];
                l++;
            }
        }
        return ans;
    }
};