leetcode刷题——数组

已于 2022-02-27 21:18:36 修改
阅读量8.1k 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： leetcode 算法 职场和发展
于 2022-02-19 17:47:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/margaret522/article/details/122177417
版权

一、二分查找

1.leetcode704(简单)

题目链接：https://leetcode-cn.com/problems/binary-search/

解题思路：题目已知条件是有序，所以考虑二分查找。

class Solution {
    public int search(int[] nums, int target) {
        int left = 0;
        int right = nums.size()-1;
       while(left <= right)
       {
           int mid = left+(right-left)/2;
           if(target == nums[mid])
            return mid;
            if(nums[mid] < target)
            {
                left = mid+1;
            }
            else
            {
                right = mid-1;
            }
       }
     return -1;
    }
}

2.leetcode35搜索插入位置（简单）

题目链接：力扣

方法1：暴力解法。时间复杂度O(n)，空间复杂度O(1)。

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

方法2：二分查找法。时间复杂度O(logn),空间复杂度O(1)。

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

3.leetcode34在排序数组中查找元素的第一个位置和最后一个位置（中等）

题目链接：力扣

解法1：利用二分查找。时间复杂度O(logn),空间复杂度O(1).

主要是找第一个＝target的位置和第一个大于target的位置。

#include<iostream>
#include <vector>
using namespace std;

class Solution {
public:
    //查找第一个等于target的下标
    int binarySearch_equal(vector<int>& nums, int target)
    {
        int left = 0;
        int right = nums.size() - 1;
        int ans = nums.size();
        while (left <= right)
        {
            int mid = left + (right - left) / 2;
            if (target <= nums[mid])
            {
                ans = mid;
                right = mid - 1;
            }
            else
            {
                left = mid + 1;
            }
        }
        return ans;
    }
    int binarySearch_greater(vector<int>& nums, int target)
    {
        int left = 0;
        int right = nums.size() - 1;
        int ans = nums.size();
        while (left <= right)
        {
            int mid = left + (right - left) / 2;
            if (target < nums[mid])
            {
                ans = mid;
                right = mid - 1;
            }
            else
            {
                left = mid + 1;
            }
        }
        return ans;
    }
    vector<int> searchRange(vector<int>& nums, int target) {
       if (nums.empty() ||target < nums[0] || target > nums[nums.size()-1]) 
            return vector<int>{-1,-1};
        else{
        int left_val = binarySearch_equal(nums, target);
        int right_val = binarySearch_greater(nums, target)-1;
        if(left_val <= right_val)
            return vector<int>{left_val, right_val};
        else
            return vector<int>{-1,-1};
    }
    }
};

解法2：利用STL现成的函数。

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int>::iterator it = find(nums.begin(),nums.end(),target);
        int left = -1;
        int right = -1;
        if(it != nums.end())
        {
            left = it-nums.begin();
            int num = count(nums.begin(),nums.end(),target);
            right = left+num-1;
        }
        return vector<int>{left,right};
    }
};

4.leetcode69x的平方根（简单）

题目链接：力扣

解法：二分查找。

易错点：注意数的范围，mid*mid可能为long long。

class Solution {
public:
    int mySqrt(int x) {
        int left = 0;
        int right = x;
        int ret = -1;
        while (left <= right)
        {
            int mid = left + (right - left) / 2;
            if ((long long)mid * mid <= x)
            {
                ret = mid;
                left = mid + 1;
            }
            else
            {
                right = mid - 1;
            }
        }
        return ret;
    }
};

5.leetcode367有效的完全平方数（简单）

题目链接：力扣

解法：二分查找法


class Solution {
public:
    bool isPerfectSquare(int num) {
        int left = 0;
        int right = num;
        while (left <= right)
        {
            int mid = left + (right - left) / 2;
            if ((long long)mid * mid == num)
            {
                return true;
            }
            else if ((long long)mid * mid > num)
            {
                right = mid - 1;
            }
            else
            {
                left = mid + 1;
            }
        }
        return false;
    }
};

总结：

寻找刚好相等的的话，直接返回mid;如果像是34或者367一样，等于条件与另一个条件混合在一起的话，设置一个变量ret记录，然后返回。

二、移除元素

1.leetcode27移除元素（简单）

题目链接：力扣

解法：双指针法。


class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slow = 0;
        for (int fast = 0;fast < nums.size();fast++)
        {
            if (nums[fast] != val)
            {
                nums[slow++] = nums[fast];
            }
        }
        return slow;
    }
};

2.leetcode26删除有序数组中的重复元素（简单）

题目链接：力扣

解法一：利用双指针法。


class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int slow = 0;
        for (int fast = 0;fast < nums.size();fast++)
        {
            if (fast== 0 ||nums[fast] != nums[fast-1])
            {
                nums[slow++] = nums[fast];
            }
        }
        return slow;
    }
};

解法二：利用STL中的erase函数。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {

        for(int i = 0;i < nums.size();i++)
        {
            if(i >0 &&(nums[i] == nums[i-1]))
            {
               nums.erase(nums.begin()+i);
                 i--;
            }
        }
        return nums.size();
    }
};

解法三：利用STL中的去重函数unique。

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

总结：unique函数原型

unique函数的函数原型如下：只有两个参数，且参数类型都是迭代器：

1

iterator unique(iterator it_1,iterator it_2);

这种类型的unique函数是我们最常用的形式。其中这两个参数表示对容器中[it_1，it_2)范围的元素进行去重(注：区间是前闭后开，即不包含it_2所指的元素),返回值是一个迭代器，它指向的是去重后容器中不重复序列的最后一个元素的下一个元素。

3.leetcode844比较含退格的字符串（简单）

题目链接：

力扣

解法一：双指针法。时间复杂度O(N+M)。空间复杂度O(1)。


//双指针
class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int i = s.size() - 1;
        int j = t.size() - 1;
        int sskipNum = 0;
        int tskipNum = 0;
        while (1)
        {
            while (i >= 0)
            {
                if (s[i] == '#')
                {
                    sskipNum++;
                }
                else
                {
                    if (sskipNum > 0)
                    {
                        sskipNum--;
                    }
                    else
                    {
                        break;
                    }
                }
                i--;
            }
            while (j >= 0)
            {
                if (t[j] == '#')
                {
                    tskipNum++;
                }
                else
                {
                    if (tskipNum > 0)
                    {
                        tskipNum--;
                    }
                    else
                    {
                        break;
                    }
                }
                j--;
            }
            if (i < 0 || j < 0) break;
            if (s[i] != t[j]) return false;
            i--;
            j--;
        }
        if (i == -1 && j == -1)
        {
            return true;
        }
        return false;
    }
};

解法二：重构字符串法。时间复杂度O(N+M)。空间复杂度O(N+M)。

//重构字符串
class Solution {
public:
    bool backspaceCompare(string s, string t) {
        return build(s) == build(t);
    }
    string build(string str)
    {
        string ret;
        for (char ch : str)
        {
            if (ch != '#')
            {
                ret.push_back(ch);
            }
            else if(!ret.empty())
            {
                ret.pop_back();
            }
        }
         return ret;
    }
};

4.leetcode977有序数组的平方（简单）

题目链接：力扣

解法一：双指针法。时间复杂度：O(n)，空间复杂度O(1)。

#include <iostream>
#include<vector>
using namespace std;
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int i, j,k;
        k = nums.size() - 1;
        vector<int> result(nums.size(), 0);
        for (i = 0, j = nums.size() - 1;i <= j;)
        {
            if (nums[i] * nums[i] > nums[j] * nums[j])
            {
                result[k--] = (nums[i] * nums[i]);
                i++;
            }
            else
            {
                result[k--]=(nums[j] * nums[j]);
                j--;
            }
        }
        return result;
    }
};

解法2：暴力解法。stl中的内置函数sort。空间复杂度：O(n+nlogn)。空间复杂度:O（logn）。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for (int i = 0;i < nums.size();i++)
        {
           nums[i]*=nums[i];
        }
        sort(nums.begin(), nums.end());
        return nums;
    }
};

注意：STL中的sort函数的时间复杂度是O（nlogn）。

三、滑动窗口

1.leetcode209长度最小的子数组。（中等）

题目连接：力扣

解法一：暴力解法。时间复杂度O(n^2),空间复杂度O(1)。

#include <iostream>
#include<vector>
using namespace std;
//暴力解法
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int result = 65535;
        int sublength = 0; //子序列长度
        for (int i = 0;i < nums.size();i++)
        {
            int sum = 0;
            for (int j = i;j < nums.size();j++)
            {
                sum += nums[j];
                if (sum >= target)
                {
                    sublength = j - i + 1;
                    result = result < sublength ? result : sublength;
                    break;
                }
            }
        }
        return result == 65535? 0 : result;
    }
};

解法二：滑动窗口——双指针。时间复杂度O(n),空间复杂度O(1) .

//滑动窗口——双指针
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int start = 0;
        int end;
        int sum = 0;
        int result = 65535;
        int sublength = 0;
        for (end = 0;end < nums.size();end++)
        {
            sum += nums[end];
            while (sum >= target)
            {
                sublength = end - start + 1;
                result = result < sublength ? result : sublength;
                sum -= nums[start++];

            }

        }
        return result == 65535 ? 0 : result;
    }
};

2.leetcode904水果成篮（中等）

题目链接：力扣

解法：滑动窗口

备注：写了很久。。。

#include<iostream>
#include<vector>
#include <map>
using namespace std;

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        map<int, int> basket;
        int i = 0;
        int result = 0;
        for (int j = 0;j < fruits.size();++j)
        {
            basket.insert(pair<int, int>(fruits[j], ++basket[fruits[j]]));
            while (basket.size() > 2)
            {
                --basket[fruits[i]];
                if(basket[fruits[i]] == 0)
                    basket.erase(fruits[i]);
                i++;
            }
            result = result > (j - i + 1) ? result : (j - i + 1);
        }
        return result;
    }
};

3.leetcode76最小覆盖子串（困难）

题目链接：力扣  

解法：滑动窗口+哈希表

class Solution {
public:
    string minWindow(string s, string t) {
        vector<int> need(128, 0);
        for (char ch:t)
        {
            need[ch]++;
        }
        int left = 0, right = 0,count = t.size(), result = 65535,start = 0;
        while (right < s.size())
        {
            if (need[s[right]] > 0)
            {
                count--;   
            }
            need[s[right]]--;
            if(count == 0)
            {
                while (left < right && need[s[left]] < 0)
                {
                    need[s[left++]]++;
                }
                if (right - left + 1 < result)
                {
                    result = right - left + 1;
                    start = left;
                }
                need[s[left]]++;
                left++;
                count++;
            }
            right++;
        }
        if(result == 65535)
        {
            return "";
        }
        else
        return s.substr(start, result);
    }
};

注意：

1.在leetcode中解决问题时，所有声明的变量必须在类内。不然会出现测试可以通过，而提交不通过的情况。这次因为把vector<int>在solution类外声明耗费了大量时间找错。

2.substr函数的第二个参数是指要截取的长度。

四、螺旋矩阵

1.leetcode59螺旋矩阵II(中等)

题目链接：力扣

解法：模拟

#include<iostream>
#include <vector>
using namespace std;
class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> result(n, vector<int>(n));
        int k = 1;
        int left = 0, right = n - 1, top = 0, bottom = n - 1;
        while (k <= n * n)
        {
            for (int i = left;i <= right;i++, k++)
            {
                result[top][i] = k;
            }
            top++;
            for (int i = top;i <= bottom;i++, k++)
            {
                result[i][right] = k;
            }
            right--;
            for (int i = right;i >= left;i--, k++)
            {
                result[bottom][i] = k;
            }
            bottom--;
            for (int i = bottom;i >= top;i--, k++)
            {
                result[i][left] = k;
            }
            left++;
        }
        return result;
    }
};

2.leetcode 54螺旋矩阵（中等）

题目链接：力扣

解法：模拟

#include<iostream>
#include<vector>
using namespace std;
class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        int rows = matrix.size();
        int columns = matrix[0].size();
        int count = rows * columns;
        vector<int> res;
        int k = 0,left = 0, right = columns - 1, top = 0, bottom = rows - 1;
        while (k < count)
        {
            for (int i = left;i <= right&&k < count;++i)
            {
                res.push_back(matrix[top][i]);
                k++;
            }
            top++;
            for (int i = top;i <= bottom&&k < count;++i)
            {
                res.push_back(matrix[i][right]);
                k++;
            }
            right--;
            for (int i = right;i >= left&&k < count;--i)
            {
                res.push_back(matrix[bottom][i]);
                k++;
            }
            bottom--;
            for (int i = bottom;i >= top&&k < count;--i)
            {
                res.push_back(matrix[i][left]);
                k++;
            }
            left++;
        }
        return res;
    }
};

3.leetcode剑指offer29顺时针打印矩阵（简单）

题目链接：力扣

解法：模拟（与上题相同）


class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        if (matrix.size() == 0 || matrix[0].size() == 0) {
            return {};
        }
        vector<int> res;
        int rows = matrix.size();
        int columns = matrix[0].size();
        int count = rows * columns;
        int left = 0, right = columns - 1, top = 0, bottom = rows - 1, k = 0;
        while (k < count)
        {
            for (int i = left;i <= right&&k<count;++i)
            {
                res.push_back(matrix[top][i]);
                k++;
            }
            top++;
            for (int i = top;i <= bottom&&k < count;++i)
            {
                res.push_back(matrix[i][right]);
                k++;
            }
            right--;
            for (int i = right;i >= left&&k < count ;--i)
            {
                res.push_back(matrix[bottom][i]);
                k++;
            }
            bottom--;
            for (int i = bottom;i >= top && k < count;--i)
            {
                res.push_back(matrix[i][left]);
                k++;
            }
            left++;
        }
        return res;
    }
};

注意：

需要考虑输入数组为空的情况。判断二维数组为空条件是行数为0或者列数为0且返回空数组的写法是：return {};上题虽然也能通过，但也需要补充这个条件。

其他题目

1.leetcode1365有多少少于当前数字的数字。（学会计数排序）

初学者清水
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Leetcode 刷题之数组类
I AM BACK
12-21 523
入门级283. Move Zeroesclass Solution { public: void swap(vector<int>& nums, int a, int b) { int tmp = nums[a]; nums[a] = nums[b]; nums[b] = tmp; } void moveZeroes(vector
LeetCode 刷题--数组
只不停的博客
02-27 1230
面试题03 数组中重复的数字 找出数组中重复的数字。 在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。 示例 1： 输入： [2, 3, 1, 0, 2, 5, 3] 输出：2 或 3 class Solution { public int findRe...
leetcode刷题之数组
weixin_47417033的博客
04-23 1282
字符串 数组字符串常见方法数组常见方法 字符串常见方法 str.length获取字符串长度 str[0]获取指定索引位置的元素 str.indexOf(‘xiao’)查找指定字符串并返回下标(>=0)。如果找不到指定字符串，返回-1 str.slice(2,6)截取字符串，第二个下标所在元素不包括。当第二个参数省略时，一直截取到最后一个，不影响原来的字符串 toLowerCase() toUpperCase() str.replace(被换下,被换上的)第一个参数使用正则表达式/app/g时可以全局
leetcode数组汇总_LeetCode刷题总结-数组篇（下）
weixin_32424885的博客
01-17 437
本期讲O(n)类型问题，共14题。3道简单题，9道中等题，2道困难题。数组篇共归纳总结了50题，本篇是数组篇的最后一篇。其他三个篇章可参考：本系列50道题是作者在LeetCode题库数组标签中包含的202道题中，按照解答考点分类归纳总结的题型。解法仅供参考，主要在于题目和考点的分类。希望对准备刷LeetCode，而感觉题目繁多、标签太多、时间较少，不知道从何开始刷题的同学一点小小的帮助^~^，也是...
LeetCode刷题题解：495. 提莫攻击
Corey11的博客
11-10 5643
495. 提莫攻击 题目：         在《英雄联盟》的世界中，有一个叫 “提莫” 的英雄。他的攻击可以让敌方英雄艾希（编者注：寒冰射手）进入中毒状态。当提莫攻击艾希，艾希的中毒状态正好持续 duration 秒。         正式地讲，提莫在 t 发起发起攻击意味着艾希在时间区间 [t, t + duration - 1]（含 t 和 t + duration - 1）处于中毒状态。如果提莫在中毒影
LeetCode 数组题
weixin_43703426的博客
04-06 242
LeetCode 数组题 268. 缺失数字 题目描述： 从一个包含 0到n 的 n-1 个数的序列nums中，找出缺失的那个数。要求线性时间复杂度，仅使用额外常数空间。 思路1： 生成一个长度加1，元素全为-1的数组a，将nums中的元素作为索引给a赋值，最后元素为-1的索引即为nums缺失的元素。但是这种做法应该不满足额外常数空间的要求。 Python代码： class Solution(ob...
LeetCode算法刷题——数组篇
cainiao22222的博客
06-01 352
算法刷题——数组篇1. 双指针（快慢指针） 1. 双指针（快慢指针） 简单篇 1 给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。 def removeDuplicates(self, nums): """ :type nums: List[int] :rtype: int """
Leetcode刷题——数组排序
qq_41060487的博客
11-22 362
Leetcode刷题——数组排序欢迎使用Markdown编辑器新的改变合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Ma
LeetCode刷题——探寻两个有序数组中位数
12-20
在LeetCode刷题的过程中，我们经常会遇到一些挑战性的问题，其中“探寻两个有序数组中位数”就是一个典型的例子。这道题目属于数组类问题，它不仅要求我们理解数组的操作，更深层次地，它考察了我们对中位数概念的...
LeetCode刷题笔记——#88. 合并两个有序数组
12-22
  由于比较，总会有一个数组先结束，对于后结束的一个数组，如果其恰好就是最终需要返回的，则无需处理。   如果是另一个数组，则直接把它的剩下值全部 copy 过去，这里看了官方题解，   发现 nums1[k-b:k+1] ...
leetcode刷题方法总结—数组全解
修行的凡人的博客
08-21 1288
leetcode解题方法全解--数组全解
Leetcode数组类题目
Bryan要加油
03-27 903
Move Zeroes：Easy。双指针。 Contains Duplicate：Easy。hashtable。 Majority Element：Easy。但是对答案的扩展不明白。 Remove Element：Easy。双指针。 Remove Duplicates from Sorted Array：Easy。双指针。 Plus One：Easy。 Pascal’s Triangle：Easy。
leetcode数组题目，数组加一
zlb666的博客
09-24 222
下面给出代码，代码应该还有可以改进的地方，欢迎指正  class Solution { public: vector&lt;int&gt; plusOne(vector&lt;int&gt;&amp; digits) { auto len=digits.size(); auto lentmp=len; ...
LeetCode刷题——Array篇(Two Sum)
lpcarl的专栏
04-23 186
Given an array of integers, return indices of the two numbers such that they add up to a specific target. You may assume that each input would have exactly one solution, and you may not use the same ...
LeetCode题目——数组篇
Pcl2001的博客
02-23 9342
LeetCode数组题目
leetcode 数组类 所有题目
yanglq的博客
07-24 409
11Container With Most Water36.5%Medium Given n non-negative integers a1, a2, ..., an, where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpo
LeetCode分类刷题---数组篇
最新发布
池鱼
01-05 928
给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。由于是要找到一个范围。所以分两次二分查找。左边界，当mid等于target还要继续往前找。直到left=right，此时找到的左边界就是小于目标值的第一个。右边界：当mid=target的适合更新left。指针的左节点就是右边界的值。
LeetCode上的Arry(数组)类型的题目
notHeadache的博客
11-02 697
文章目录Easy905. Sort Array By Parity832. Flipping an Image561. Array Partition I867. Transpose Matrix 矩阵的转置766. Toeplitz Matrix896. Monotonic Array 单调数组485. Max Consecutive Ones 二进制数组中最长的1888. Fair Cand...
Leetcode数组基础题目总结（Python实现）
学习路径记录，文献学习记录，项目记录。
01-23 644
对leetcode数组基础题目总结
LeetCode刷题攻略：数组、字符串与树
"该资源是关于LeetCode刷题的指南，涵盖了数组类、字符串类以及Tree类等编程题目，旨在帮助编程学习者有效提升算法能力。" 数组类题目是编程面试中常见的类型，它们主要考察对数组操作的理解和熟练度。例如： 1. ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值