力扣刷题之数组（二）

最新推荐文章于 2022-01-19 16:26:02 发布
最新推荐文章于 2022-01-19 16:26:02 发布
阅读量101 收藏
点赞数
分类专栏： 力扣 数据结构与算法 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41191468/article/details/120776323
版权

力扣刷题之数组（二）

200.岛屿数量

在这里插入图片描述

class Solution {
private:
    void dfs(vector<vector<char>>& grid, int r, int c) {
        int nr = grid.size();
        int nc = grid[0].size();

        grid[r][c] = '0';
        if (r - 1 >= 0 && grid[r-1][c] == '1') dfs(grid, r - 1, c);
        if (r + 1 < nr && grid[r+1][c] == '1') dfs(grid, r + 1, c);
        if (c - 1 >= 0 && grid[r][c-1] == '1') dfs(grid, r, c - 1);
        if (c + 1 < nc && grid[r][c+1] == '1') dfs(grid, r, c + 1);
    }

public:
    int numIslands(vector<vector<char>>& grid) {
        int nr = grid.size();
        if (!nr) return 0;
        int nc = grid[0].size();

        int num_islands = 0;
        for (int r = 0; r < nr; ++r) {
            for (int c = 0; c < nc; ++c) {
                if (grid[r][c] == '1') {
                    ++num_islands;
                    dfs(grid, r, c);
                }
            }
        }

        return num_islands;
    }
};

204.计数质数

在这里插入图片描述
法一：枚举(超时）
在这里插入图片描述

class Solution {
public:
    bool isPrime(int x) {
        for (int i = 2; i * i <= x; ++i) {
            if (x % i == 0) {
                return false;
            }
        }
        return true;
    }

    int countPrimes(int n) {
        int ans = 0;
        for (int i = 2; i < n; ++i) {
            ans += isPrime(i);
        }
        return ans;
    }
};

法二：埃氏筛（好神奇）

在这里插入图片描述

class Solution {
public:
    int countPrimes(int n) {
        vector<int> isPrime(n, 1);
        int ans = 0;
        for (int i = 2; i < n; ++i) {
            if (isPrime[i]) {
                ans += 1;
                if ((long long)i * i < n) {
                    for (int j = i * i; j < n; j += i) {
                        isPrime[j] = 0;
                    }
                }
            }
        }
        return ans;
    }
};

209.长度最小的子数组

在这里插入图片描述
法一：暴力法
在这里插入图片描述

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }
        int ans = INT_MAX;
        for (int i = 0; i < n; i++) {
            int sum = 0;
            for (int j = i; j < n; j++) {
                sum += nums[j];
                if (sum >= s) {
                    ans = min(ans, j - i + 1);
                    break;
                }
            }
        }
        return ans == INT_MAX ? 0 : ans;
    }
};

法二：滑动窗口
在这里插入图片描述

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }
        int ans = INT_MAX;
        int start = 0, end = 0;
        int sum = 0;
        while (end < n) {
            sum += nums[end];
            while (sum >= s) {
                ans = min(ans, end - start + 1);
                sum -= nums[start];
                start++;
            }
            end++;
        }
        return ans == INT_MAX ? 0 : ans;
    }
};

法三：前缀和+二分查找
在这里插入图片描述

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }
        int ans = INT_MAX;
        vector<int> sums(n + 1, 0); 
        // 为了方便计算，令 size = n + 1 
        // sums[0] = 0 意味着前 0 个元素的前缀和为 0
        // sums[1] = A[0] 前 1 个元素的前缀和为 A[0]
        // 以此类推
        for (int i = 1; i <= n; i++) {
            sums[i] = sums[i - 1] + nums[i - 1];
        }
        for (int i = 1; i <= n; i++) {
            int target = s + sums[i - 1];
            auto bound = lower_bound(sums.begin(), sums.end(), target);
            if (bound != sums.end()) {
                ans = min(ans, static_cast<int>((bound - sums.begin()) - (i - 1)));
            }
        }
        return ans == INT_MAX ? 0 : ans;
    }
};

215.数组中的第K个最大元素（经典！）

在这里插入图片描述
法一：大根堆
在这里插入图片描述
大根堆调库：

class Solution 
{
public:
    int findKthLargest(vector<int>& nums, int k) 
    {
        priority_queue<int, vector<int>, less<int>> maxHeap;
        for (int x : nums)
            maxHeap.push(x);
        for (int _ = 0; _ < k - 1; _ ++)
            maxHeap.pop();
        return maxHeap.top();
    }
};

手撸大根堆：

class Solution {
public:
    void maxHeapify(vector<int>& a, int i, int heapSize) {
        int l = i * 2 + 1, r = i * 2 + 2, largest = i;
        if (l < heapSize && a[l] > a[largest]) {
            largest = l;
        } 
        if (r < heapSize && a[r] > a[largest]) {
            largest = r;
        }
        if (largest != i) {
            swap(a[i], a[largest]);
            maxHeapify(a, largest, heapSize);
        }
    }

    void buildMaxHeap(vector<int>& a, int heapSize) {
        for (int i = heapSize / 2; i >= 0; --i) {
            maxHeapify(a, i, heapSize);
        } 
    }

    int findKthLargest(vector<int>& nums, int k) {
        int heapSize = nums.size();
        buildMaxHeap(nums, heapSize);
        for (int i = nums.size() - 1; i >= nums.size() - k + 1; --i) {
            swap(nums[0], nums[i]);
            --heapSize;
            maxHeapify(nums, 0, heapSize);
        }
        return nums[0];
    }
};

法二：快排
在这里插入图片描述

class Solution {
public:
    int findKthLargest(vector<int>& nums, int k) {
        int n=nums.size();
        int le=0, ri=n-1;
        while(true){  
            //快排框架
            int i=le, j=ri;
            int idx = rand() % (ri - le +1) + le;//随机选择pivot
            swap(nums[le], nums[idx]);
            while(i<j){
                while(i<j&&nums[j]>=nums[le]) --j;
                while(i<j&&nums[i]<=nums[le]) ++i;
                swap(nums[i], nums[j]);
            }
            swap(nums[i], nums[le]);//nums[le]应处的位置在索引i处

            if(i==n-k) return nums[i];//若恰为倒数第K的位置
            else if(i>n-k) ri=i-1;//将查找范围放在该位置左侧
            else le=i+1;//将查找范围放在该位置右侧
        }
    }
};

220.存在重复元素III（经典）

在这里插入图片描述
法一：滑动窗口+有序集合
在这里插入图片描述

class Solution {
public:
    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
        int n = nums.size();
        set<int> rec;
        for (int i = 0; i < n; i++) {
            auto iter = rec.lower_bound(max(nums[i], INT_MIN + t) - t);
            if (iter != rec.end() && *iter <= min(nums[i], INT_MAX - t) + t) {
                return true;
            }
            rec.insert(nums[i]);
            if (i >= k) {
                rec.erase(nums[i - k]);
            }
        }
        return false;
    }
};

法二：桶
在这里插入图片描述

class Solution {
public:
    int getID(int x, long w) {
        return x < 0 ? (x + 1ll) / w - 1 : x / w;
    }

    bool containsNearbyAlmostDuplicate(vector<int>& nums, int k, int t) {
        unordered_map<int, int> mp;
        int n = nums.size();
        for (int i = 0; i < n; i++) {
            long x = nums[i];
            int id = getID(x, t + 1ll);
            if (mp.count(id)) {
                return true;
            }
            if (mp.count(id - 1) && abs(x - mp[id - 1]) <= t) {
                return true;
            }
            if (mp.count(id + 1) && abs(x - mp[id + 1]) <= t) {
                return true;
            }
            mp[id] = x;
            if (i >= k) {
                mp.erase(getID(nums[i - k], t + 1ll));
            }
        }
        return false;
    }
};

221.最大正方形

在这里插入图片描述
在这里插入图片描述
动态规划
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    int maximalSquare(vector<vector<char>>& matrix) {
        if (matrix.size() == 0 || matrix[0].size() == 0) {
            return 0;
        }
        int maxSide = 0;
        int rows = matrix.size(), columns = matrix[0].size();
        vector<vector<int>> dp(rows, vector<int>(columns));
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                if (matrix[i][j] == '1') {
                    if (i == 0 || j == 0) {
                        dp[i][j] = 1;
                    } else {
                        dp[i][j] = min(min(dp[i - 1][j], dp[i][j - 1]), dp[i - 1][j - 1]) + 1;
                    }
                    maxSide = max(maxSide, dp[i][j]);
                }
            }
        }
        int maxSquare = maxSide * maxSide;
        return maxSquare;
    }
};

229.求众数II

在这里插入图片描述
摩尔投票法
时间复杂度为O(n),空间复杂度为O(1)
在这里插入图片描述

class Solution {
public:
    vector<int> majorityElement(vector<int>& nums) {
        vector<int> ans;
        if (nums.empty()) return ans;
        int cand1, cand2;
        int count1, count2;
        cand1 = cand2 = count1 = count2 = 0;
        // 抵消阶段
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] == cand1) count1++;
            else if (nums[i] == cand2) count2++;
            else if (count1 && count2) {
                count1--;
                count2--;
            }
            else if (!count1) {
                cand1 = nums[i];
                count1++;
            }
            else {
                cand2 = nums[i];
                count2++;
            }
        }
        // 计数阶段
        count1 = count2 = 0;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] == cand1) count1++;
            else if(nums[i] == cand2) count2++; // 必须用else if，保证每个数只算到一个候选人头上
            else {}
        }
        if (count1 > nums.size() / 3) ans.push_back(cand1);
        if (count2 > nums.size() / 3) ans.push_back(cand2);
        return ans;
    }
};

238.除自身以外数组的乘积

在这里插入图片描述
法一：左右乘积列表
在这里插入图片描述

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int length = nums.size();

        // L 和 R 分别表示左右两侧的乘积列表
        vector<int> L(length, 0), R(length, 0);

        vector<int> answer(length);

        // L[i] 为索引 i 左侧所有元素的乘积
        // 对于索引为 '0' 的元素，因为左侧没有元素，所以 L[0] = 1
        L[0] = 1;
        for (int i = 1; i < length; i++) {
            L[i] = nums[i - 1] * L[i - 1];
        }

        // R[i] 为索引 i 右侧所有元素的乘积
        // 对于索引为 'length-1' 的元素，因为右侧没有元素，所以 R[length-1] = 1
        R[length - 1] = 1;
        for (int i = length - 2; i >= 0; i--) {
            R[i] = nums[i + 1] * R[i + 1];
        }

        // 对于索引 i，除 nums[i] 之外其余各元素的乘积就是左侧所有元素的乘积乘以右侧所有元素的乘积
        for (int i = 0; i < length; i++) {
            answer[i] = L[i] * R[i];
        }

        return answer;
    }
};

法二：空间复杂度为O（1）
在这里插入图片描述

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        int length = nums.size();
        vector<int> answer(length);

        // answer[i] 表示索引 i 左侧所有元素的乘积
        // 因为索引为 '0' 的元素左侧没有元素， 所以 answer[0] = 1
        answer[0] = 1;
        for (int i = 1; i < length; i++) {
            answer[i] = nums[i - 1] * answer[i - 1];
        }

        // R 为右侧所有元素的乘积
        // 刚开始右边没有元素，所以 R = 1
        int R = 1;
        for (int i = length - 1; i >= 0; i--) {
            // 对于索引 i，左边的乘积为 answer[i]，右边的乘积为 R
            answer[i] = answer[i] * R;
            // R 需要包含右边所有的乘积，所以计算下一个结果时需要将当前值乘到 R 上
            R *= nums[i];
        }
        return answer;
    }
};

240.搜索二维矩阵II

在这里插入图片描述
在这里插入图片描述
法一：单调性扫描（线性扫描）
在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        if(!matrix.size() && !matrix[0].size()) return false;
        int i = 0, j = matrix[0].size() - 1;  //矩阵右上角
        while(i < matrix.size() && j >= 0)
        {
            if(matrix[i][j] == target)  return true;
            else if( matrix[i][j] < target) i++;  //排除一行
            else if( matrix[i][j] > target) j--;  //排除一列
        }
        return false;
    }
};

法二：二分法

class Solution {
public:
    bool bsearch(vector<vector<int>>& matrix, int target,int line){
        int l = 0; int r  = matrix[line].size()-1;
        while(l<r){
            int mid = l+r>>1;
            if(matrix[line][mid] >= target){ r =mid; }
            else { l = mid+1;}
        }
        if(matrix[line][l] == target) return true;
        return false;
    }

    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        for(int i = 0; i < matrix.size();i++){
            if(matrix[i][0] > target){break;}
            if( matrix[i].back() < target) {continue;}
            if(bsearch(matrix,target,i) == true) return true;
        }
        return false;
    }
};

260.只出现一次的数字III

在这里插入图片描述
异或法（线性时间复杂度，常数空间复杂度）
在这里插入图片描述

class Solution {
public:
    vector<int> singleNumber(vector<int>& nums) {
        int ret = 0;
        for (int n : nums)
            ret ^= n;
        int div = 1;
        while ((div & ret) == 0)
            div <<= 1;
        int a = 0, b = 0;
        for (int n : nums)
            if (div & n)
                a ^= n;
            else
                b ^= n;
        return vector<int>{a, b};
    }
};

剑指Offer II 080.含有k个元素的组合

在这里插入图片描述
回溯+递归

// 回溯算法
class Solution {
public:
    vector<vector<int>> combine(int n, int k) {
        path.clear();
        ans.clear();
        backtrack(n, k, 1);
        return ans;
    }
private:
    vector<int> path;
    vector<vector<int>> ans;
    void backtrack(int n, int k, int index) {
        // 当子集里面有两个数的时候，则终止递归
        if (path.size() == k) {
            ans.push_back(path);
            return;
        }
        // for循环遍历集合区间
        for (int i = index; i <= n; i++) {
            path.push_back(i);
            backtrack(n, k, i + 1);//递归
            path.pop_back();//回溯
        }
    }
};

剑指Offer II 079.所有子集

在这里插入图片描述

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;
    void dfs(vector<int> nums,int pos){
        ans.push_back(path);
        for(int i = pos; i < nums.size() ; i++){
            path.push_back(nums[i]);
            dfs(nums,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        int n = nums.size();
        dfs(nums,0);
        return ans;
    }
};
南不喃
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大根堆与小根堆的理解，如何手写一个堆，以及什么时候用自己手写的堆，什么时候用语言提供堆的api，（二者的区别）
weixin_44213940的博客
01-16 3623
大根堆与小根堆的理解，如何手写一个堆，以及什么时候用自己手写的堆，什么时候用语言提供堆的api，（二者的区别） 定义 Heap是一种数据结构具有以下的特点： 1）完全二叉树； 2）heap中存储的值是偏序； Min-heap: 父节点的值小于或等于子节点的值； Max-heap: 父节点的值大于或等于子节点的值； 用通俗语言来说，大根堆就是每个最大的数字在每个子树的最上方，及大根堆pop值为最大值，小根堆反之 堆的存储 堆的存储一般由数组表示，由于堆的实质就是完全二叉树，所以对于每个i来说（从0开始）,左
【力扣刷题】数组-链表-哈希-双指针
06-21
二分查找的前提条件是：数组为有序数组，数组中无重复元素。（因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的。） 二分查找法的实现可以使用两种方式：左闭右闭和左闭右开。左闭右闭方式的实现...
剑指offer—topK问题，最小的k个数——手写大根堆（堆排变形），快排变形Partition
八吨车的博客
05-06 294
题意：输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。 类似这种topK问题，都可以用堆排序的变形来解决 堆排序代码： #include<iostream> #include<vector> using namespace std; // 递归方式构建大根堆(len是arr的长度，in...
手撸一个A*+二叉堆优化（四）
lvcoc的博客
01-24 1478
二叉堆是堆的一种，使用完全二叉树来实现。所谓完全二叉树，即高度为n的二叉树，其前n-1层必须被填满，第n层也要从左到右顺序填满。在二叉堆中，所有非终端结点的值均不大于（或不小于）其左右孩子的值。若非终端结点的值均不大于其左右孩子结点的值，这样的二叉堆叫做小根堆（图（b）），小根堆根结点的值是该堆中所有结点的最小值；同样的，当所有非终端结点的值都不小于其左右孩子的值时，这样的对叫做大根堆（图（a...
leetcode练习——排序和搜索（数组中的第K个最大元素）
strivequeen的博客
10-13 95
优秀解析： （1）大根堆–调库 （2）手撸大根堆 （3）快排3种写法 基于快排的所有TopK问题简单python模板 解法一：快排 左右挖坑互填： class Solution: def findKthLargest(self, nums: List[int], k: int) -> int: n = len(nums) l = 0 r = n - 1 while True: idx = self.p.
手写大根堆
Harrison的学习博客
11-30 444
用数组实现一个大根堆 实现功能 每给一个数加进数组后，自动调整为大根堆结构（heapInsert()方法） 返回大根堆中的最大值，并且在大根堆中把最大值删除，且剩下的数，依然保持为大根堆结构（heapify()方法） 自己手写一个大根堆结构 VS 纯暴力的方法，用对数器测试100万组！！！ package com.harrison.class04; public class Code01_MaxHeap { public static class MyMaxHeap { private int[
力扣刷题笔记总结记录666
最新发布
01-13
"力扣刷题笔记总结记录666" 本资源摘要信息对应的知识点主要涉及到链表、哈希表、栈等数据结构的概念和应用。 一、链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的...
力扣刷题 | 二叉树
12-20
文章目录总述基本概念二叉树性质二叉树遍历94 二叉树的中序遍历95 不同的二叉搜索树296 不同的二叉搜索树98 验证二叉搜索树100 ...数组转换为二叉搜索树109 有序链表转换二叉搜索树110 平衡二叉树111 二叉树的最小深度...
力扣刷题集-更新至链表
06-21
力扣刷题集-更新至链表 本资源摘要信息主要涉及算法领域，着重于数组、链表、排序算法、二分查找等知识点。 数组 数组是存放在连续内存空间上的相同类型数据的集合。数组可以方便地通过下标索引的方式获取到下标...
leetcode跳跃-LeetCode:力扣刷题70道！
06-30
力扣刷题70道！ 数组 Array 力扣 485 最大连续1的个数 | Max Consecutive One 力扣 283 移动零 | Move Zeroes 力扣 27 移除元素 | Remove Element 链表 Linked List 力扣 203 移除链表元素 | Remove Linked List ...
由vector的size()函数引发的越界问题
qq_41191468的博客
01-16 900
由vector的size()函数引发的越界问题 在做剑指 Offer 04. 二维数组中的查找一题时，如下代码： class Solution { public: bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) { int i = matrix.size() - 1, j = 0; while (i >= 0 && j <=
力扣刷题之深度优先搜索
qq_41191468的博客
11-10 767
力扣刷题之深度优先搜索98.验证二叉搜索树99.恢复二叉搜索树113.路径总和II114.二叉树展开为链表116.填充每个节点的下一个右侧节点指针117.填充每个节点的下一个右侧节点指针II129.求根节点到叶节点数字之和199.二叉树的右视图 98.验证二叉搜索树 法一：递归 class Solution { public: bool helper(TreeNode* root, long long lower, long long upper) { if (root == n
力扣刷题之排序
qq_41191468的博客
11-17 521
力扣刷题之排序 147.对链表进行插入排序148.排序链表 147.对链表进行插入排序 class Solution { public: ListNode* insertionSortList(ListNode* head) { if (head == nullptr) { return head; } ListNode* dummyHead = new ListNode(0); dummyHead->
剑指Offer 19.正则表达式匹配
qq_41191468的博客
01-19 342
剑指Offer 19.正则表达式匹配 示例 1: 输入: s = “aa” p = “a” 输出: false 解释: “a” 无法匹配 “aa” 整个字符串。 示例 2: 输入: s = “aa” p = “a*” 输出: true 解释: 因为 ‘*’ 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 ‘a’。因此，字符串 “aa” 可被视为 ‘a’ 重复了一次。 示例 3: 输入: s = “ab” p = “.*” 输出: true 解释: “.*” 表示可匹配零个或多个（
力扣刷题之动态规划
qq_41191468的博客
08-28 253
力扣刷题之动态规划509.斐波那契数列70.爬楼梯746.使用最小花费爬楼梯62.不同路径63.不同路径II343.整数拆分96.不同的二叉搜索树01背包问题416.分割等和子集1049.最后一块石头的重量II494.目标和474.一和零完全背包问题518.零钱兑换II（可以照葫芦画瓢写了）377.组合总数IV322.零钱兑换279.完全平方数139.单词拆分多重背包背包问题总结打家劫舍198.打家劫舍213.打家劫舍II337.打家劫舍III(好难呜呜）树形贪心121.买卖股票的最佳时机（只买卖一次）12
力扣刷题之哈希表
qq_41191468的博客
10-27 184
力扣刷题之哈希表133.克隆图138.复制带随机指针的链表146.LRU缓存机制（手写双向链表）202.快乐数 133.克隆图 法一：深度搜索 class Solution { public: unordered_map<Node*, Node*> visited; Node* cloneGraph(Node* node) { if (node == nullptr) { return node; }
力扣刷题之二叉树
qq_41191468的博客
07-26 180
二叉树94、二叉树的中序遍历100、相同的树101、对称二叉树104、二叉树的最大深度108、将有序数组转换为二叉搜索树110、平衡二叉树111、二叉树的最小深度112、路径总和 94、二叉树的中序遍历 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0),
力扣刷题之数组
qq_41191468的博客
09-28 175
力扣刷题之数组41.缺失的第一个正数42.接雨水54.螺旋矩阵56.合并区间57.插入区间59.螺旋矩阵II64.最小路径和73.矩阵置零74.搜索二维矩阵75.颜色分类79.单词搜索26.删除有序数组中的重复项80.删除有序数组中的重复项II 41.缺失的第一个正数 https://leetcode-cn.com/problems/first-missing-positive/solution/que-shi-de-di-yi-ge-zheng-shu-by-leetcode-solution/
剑指Offer-30.第一个只出现一次的字符
qq_41191468的博客
09-07 173
法一：哈希表 class Solution { public: char firstUniqChar(string s) { unordered_map<int,int>map;//注意map里面的类型 //if(s==" ")return ' '; for(int i=0;i<s.size();i++){ map[s[i]]++; } for(int i=0;i<s..
力扣刷题C++常用操作
10-18
好的，关于力扣刷题C++常用操作，我可以给你一些常见的操作和技巧： 1. 使用 STL 容器和算法库：STL（Standard Template Library）是 C++ 标准库中的一个重要组成部分，包含了许多常用的容器和算法。在力扣刷题中，使用 STL 可以大大提高代码的效率和可读性。例如，vector 可以用来存储动态数组，sort 可以用来排序等等。 2. 使用 auto 关键字：auto 关键字可以自动推导变量类型，可以减少代码量和提高可读性。例如，auto x = 1; 可以自动推导出 x 的类型为 int。 3. 使用 lambda 表达式：lambda 表达式是 C++11 中引入的一种匿名函数，可以方便地定义一些简单的函数对象。在力扣刷题中，使用 lambda 表达式可以简化代码，例如在 sort 函数中自定义比较函数。 4. 使用位运算：位运算是一种高效的运算方式，在力扣刷题中经常会用到。例如，左移运算符 << 可以用来计算 2 的幂次方，右移运算符 >> 可以用来除以 2 等等。 5. 使用递归：递归是一种常见的算法思想，在力扣刷题中也经常会用到。例如，二叉树的遍历、链表的反转等等。 6. 使用 STL 中的 priority_queue：priority_queue 是 STL 中的一个容器，可以用来实现堆。在力扣刷题中，使用 priority_queue 可以方便地实现一些需要维护最大值或最小值的算法。 7. 使用 STL 中的 unordered_map：unordered_map 是 STL 中的一个容器，可以用来实现哈希表。在力扣刷题中，使用 unordered_map 可以方便地实现一些需要快速查找和插入的算法。 8. 使用 STL 中的 string：string 是 STL 中的一个容器，可以用来存储字符串。在力扣刷题中，使用 string 可以方便地处理字符串相关的问题。 9. 注意边界条件：在力扣刷题中，边界条件往往是解决问题的关键。需要仔细分析题目，考虑各种边界情况，避免出现错误。 10. 注意时间复杂度：在力扣刷题中，时间复杂度往往是评判代码优劣的重要指标。需要仔细分析算法的时间复杂度，并尽可能优化代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值