力扣题（数组篇）

已于 2023-09-18 14:56:02 修改
阅读量86 收藏
点赞数
分类专栏： 力扣 文章标签： leetcode 算法
于 2023-09-14 15:20:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44807946/article/details/132688580
版权

力扣刷题


虽然很菜，走得很慢，但也在前进。加油呀！

两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
在这里插入图片描述
题解

//C++
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        //vector<int> num;
        // int {i,j};
        for(int i = 0 ; i < nums.size(); i++){
            for(int j = i + 1 ; j < nums.size() ; j++)
            if(nums[i] + nums[j] == target){
                return {i,j};
            }
        }
        return {};
        // for(int k = 0 ; k < num.length ; k++)
        //     cout << num[k];
    }
};

寻找两个正序数组的中位数

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。
算法的时间复杂度应该为 O(log (m+n)) 。
在这里插入图片描述
题解

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        if(nums1.size() > nums2.size()){
            return findMedianSortedArrays(nums2,nums1);
        }

        int m , n;
        m = nums1.size();
        n = nums2.size();
        int left = 0, right = m;
        int median1 = 0,median2 = 0;
        while(left <= right){
            int i = (left + right) / 2;
            int j = (m + n + 1) / 2 - i;
            int nums_im1 = (i == 0 ? INT_MIN : nums1[i - 1]);
            int nums_i = (i == m ? INT_MAX : nums1[i]);
            int nums_jm1 = (j == 0 ? INT_MIN : nums2[j - 1]);
            int nums_j = (j == n ? INT_MAX : nums2[j]);

            if(nums_im1 <= nums_j){
                median1 = max(nums_im1,nums_jm1);
                median2 = min(nums_i,nums_j);
                left = i + 1;
            }else{
                right = i - 1;
            }
        }
        return (m + n) % 2 == 0 ? (median1 + median2) /2.0 : median1;

    }
};

二分查找

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
在这里插入图片描述
写法一：
定义 target 是在一个在左闭右闭的区间里，也就是[left, right]

  • while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <=
  • if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size()-1;
        while(left<=right){
            // int middle = left + ((right-left)/2);//防止溢出
            int middle = (left + right)/2;
            if(nums[middle] > target){
                right = middle - 1;
            }   
            else if(nums[middle] < target){
                left = middle + 1;
            }   
            else
                return middle;
        }
        return -1;
    }
};

时间复杂度：O(log n)
空间复杂度：O(1)

写法二：

  • while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
  • if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，而寻找区间是左闭右开区间，所以right更新为middle，即：下一个查询区间不会去比较nums[middle]
// 版本二
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size(); // 定义target在左闭右开的区间里，即：[left, right)
        while (left < right) { // 因为left == right的时候，在[left, right)是无效的空间，所以使用 <
            int middle = left + ((right - left) >> 1);//位运算 + 防止大数溢出
            if (nums[middle] > target) {
                right = middle; // target 在左区间，在[left, middle)中
            } else if (nums[middle] < target) {
                left = middle + 1; // target 在右区间，在[middle + 1, right)中
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值，直接返回下标
            }
        }
        // 未找到目标值
        return -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;
            //else if(nums[i] > target)
        }
        return nums.size();
    }
};

二分法

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        // for(int i = 0;i < nums.size();i ++ ){
        //     if(nums[i] >= target)
        //         return i;
        //     //else if(nums[i] > target)
        // }
        // return nums.size();
        int n = nums.size();
        int left = 0;
        int right =  n - 1;// 定义target在左闭右闭的区间里，[left, right]
        while(left <= right){ //当left==right，区间[left, right]依然有效
            int middle = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
            if(nums[middle] < target) left = middle + 1;// target 在右区间，所以[middle + 1, right]
            else if(nums[middle] > target) right = middle - 1;// target 在左区间，所以[left, middle - 1]
            else return middle;
        }
        // 分别处理如下四种情况
        // 目标值在数组所有元素之前  [0, -1]
        // 目标值等于数组中某一个元素  return middle;
        // 目标值插入数组中的位置 [left, right]，return  right + 1
        // 目标值在数组所有元素之后的情况 [left, right]， 因为是右闭区间，所以 return right + 1
        return right + 1;
    }
};

移除元素

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
在这里插入图片描述

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

在排序数组中查找元素的第一个和最后一个位置

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值 target，返回 [-1, -1]。你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。
在这里插入图片描述

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int leftBorder = getLeftBorder(nums,target);
        int rightBorder = getRightBorder(nums,target);
        if(leftBorder == -2 || rightBorder == -2) return {-1,-1};
        if(rightBorder - leftBorder > 1) return {leftBorder + 1,rightBorder - 1};
        return {-1,-1}; 
    }
    
private:
    int getRightBorder(vector<int>& nums, int target){
        int left = 0;
        int right = nums.size() - 1;
        int rightBorder = -2;
        while(left <= right){
            int middle = left + ((right - left) / 2);
            if(nums[middle] > target) right = middle - 1;
            else{
                left = middle + 1;
                rightBorder = left;
            }
        }
        return rightBorder;
    }

    int getLeftBorder(vector<int>& nums,int target){
        int left = 0;
        int right = nums.size() - 1;
        int leftBorder = -2;
        while(left <= right){
            int middle = left + ((right - left)/2);
            if(nums[middle] < target) left = middle + 1;
            else if(nums[middle] >= target){
                right = middle - 1;
                leftBorder = right;
            }
        }
        return leftBorder;
    }
};

有序数组的平方

给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。
在这里插入图片描述
双指针法
讲解链接： 双指针法经典题目!LeetCode:977.有序数组的平方

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

有效的完全平方数

给你一个正整数 num 。如果 num 是一个完全平方数，则返回 true，否则返回 false 。
完全平方数是一个可以写成某个整数的平方的整数。换句话说，它可以写成某个整数和自身的乘积。
不能使用任何内置的库函数，如sqrt 。
在这里插入图片描述
题解：
使用二分查找来优化方法二中的搜索过程。因为 num是正整数，所以若正整数 x满足 x×x=num，则 x一定满足 1≤x≤num。可以将 1 和 num作为二分查找搜索区间的初始边界。

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

移动零

题目描述：
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。
力扣题目链接：
283.移动零
C++代码：
双指针

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n = nums.size();
        int fast = 0, slow = 0;
        while(fast < n){
            if(nums[fast]){
                swap(nums[slow],nums[fast]);
                slow++;
            }
            fast++;
        }
    }
};

螺旋矩阵II

题目描述：
给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。
示例:
输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]
链接：
力扣题目链接
解析：
螺旋矩阵II解析
C++代码：

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> nums(n,vector<int>(n,0));
        int startx = 0, starty = 0;
        int i,j;
        int loop = n / 2;
        int offset = 1, count = 1;
        while(loop--){
            i = startx;
            j = starty;
            for(j = starty; j < n - offset ; j++){
                nums[startx][j] = count++;
            }
            for(i = startx; i < n - offset; i++){
                nums[i][j] = count++;
            }
            for(; j > starty; j--){
                nums[i][j] = count++;
            }
            for(; i >startx; i--){
                nums[i][j] = count++;
            }
            startx++;
            starty++;
            offset++;
            
        }
        if(n % 2 == 1) nums[n/2][n/2] = count;
        return nums;
    }
};

比较含退格的字符串

题目描述：
给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。
注意：如果对空文本输入退格字符，文本继续为空。
在这里插入图片描述

解析：
使用双指针的方法
逆序遍历字符串，确定当前字符是否被删掉，skip表示待删除的数量，遍历字符：

  • 该字符是退格符，多删除一个普通字符，skip+1;
  • 该字符是普通字符，若skip==0，字符不删；若skip!=0，删掉，skip-1;

思路：
1、定义两个指针分别指向字符串末尾
2、遍历两个字符串，直到两个字符串各自确定一个字符，然后比较
3、重复2，直到俩字符不等或者遍历完。

C++代码：

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int i = s.length() - 1;
        int j = t.length() - 1;
        int skip_s = 0, skip_t = 0;
        while(i >= 0 || j >= 0){
            while(i >= 0){
                if(s[i] == '#'){
                    skip_s++;
                    i--;
                }else if(skip_s > 0){
                    skip_s--;
                    i--;
                }else break;
            }
            while(j >= 0){
                if(t[j] == '#'){
                    skip_t++;
                    j--;
                }else if(skip_t > 0){
                    skip_t--;
                    j--;
                }else break;
            }
            if(i >= 0 && j >= 0){
                if(s[i] != t[j]) return false;
            }else{
                if(i >= 0 || j >= 0) return false;
            }
            i--;
            j--;
        }
        return true;
    }
};

904.水果成篮

题目描述
你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。
你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：

  • 你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
  • 你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
  • 一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。
    给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。
    在这里插入图片描述
class Solution { public: int totalFruit(vector& fruits)

{
	int n = fruits.size();
	unordered_map<int, int>count;//建立哈希表counts
	int i = 0;//窗口起始值
	int ans = 0;//result返回值而已
	for (int j = 0; j < n; j++)
	{
		count[fruits[j]]++;//往哈希表里存放数值，fruits[j]代表的是新的尾部数值，存入哈希表
		//因为是数值，不知道是否相同，存就完了，一个数值对应一个键值
		//这块就判断键值大小了
		while (count.size() > 2)//防止两个键值以上，俩篮子
		{
			auto it = count.find(fruits[i]);//找到当前这个值，并把它的个数赋给it
			--it->second;//对它的值进行减减操作
			if (it->second == 0)//值=0，=0意味着就它老哥一个，删了就删了
			{
				count.erase(it);//抹掉这个桶  
			}
			++i;//左边界右移，咋地都得给他右移
		}
		ans = max(ans, j - i + 1);//比较大小哪个大要哪个，每次循环结束更新当前长度，因为是桶数大于2才会进入这里
	}
	return ans;//返回result
}
};
W起名有点难
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
200道大数据面试常考Leetcode算法题--数组篇02（python带代码解析）
guihua55的博客
08-10 1102
往期内容在这里： 往期01-05 往期06-10 往期11-15 往期16-20 数组篇01 大家好，继续为大家推荐200道大数据面试常考Leetcode算法题，这期为--数组篇，附带解析，都是从Leetcode官网总结大神们的解法（在这里感谢大神的帮助，我只是个搬运工！）每篇更新5篇，一共更新数组篇20篇，艾瑞巴迪和我一起刷起来！！ 200道大数据面试常考Leetcode算法题（数组篇）35- 搜索插入位置 Leetcode原题： 题解为 ： class Solution:
力扣——数组篇（二分查找及相似题）
xiaowanziddd的博客
03-11 233
力扣——数组篇（二分查找及相似题） 1.给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。 思路：利用二分查找，每次都查找数组中间位置的数与目标数进行匹配。 ① 如果相等就返回该元素的下标； ②如果目标数大于该数，则下一次寻找就从中间位置到最后； ③如果目标数小于该数，则下一次寻找就从头到中间位置。 难点在于边界的考虑，其实如果左指针<=又指针的话，就说明在比较的时候是一个闭区间，
力扣刷题 | 数组专题
weixin_45904051的博客
04-18 266
跟着力扣和代码随想录在刷题，写写笔记和心得！！！！
萌新刷力扣——数组篇
ikkkp的博客
09-06 281
该专栏组旨在记录学习力扣算法题，分享解题心得。
力扣刷题 数组篇 第1331题 数组序号转换
xuewei_ing的博客
11-22 337
1.题目描述： 给你一个整数数组arr ，请你将数组中的每个元素替换为它们排序后的序号。 序号代表了一个元素有多大。序号编号的规则如下： 序号从 1 开始编号。 一个元素越大，那么序号越大。如果两个元素相等，那么它们的序号相同。 每个数字的序号都应该尽可能地小。 2.示例输出： 输入：arr = [40,10,20,30] 输出：[4,1,2,3] 解释：40 是最大的元素。 10 是最小的元素。 20 是第二小的数字。 30 是第三小的数字。 输入：arr = [100,100..
力扣刷题之数组篇
qq_51423963的博客
01-07 789
二分法、双指针
【力扣篇一】数组30道题汇总
成长之路
12-10 1086
力扣，数组三十题。
力扣之数组篇 物归原主法 秒杀 448 442 41
南七行者的博客
04-10 298
一、前言 1.物归原主法 给定一数组，其长度为n，其元素a[i]∈[0,n−1]\in[0, n - 1]∈[0,n−1]时，当我们把a[i]放到i = a[i]的位置时，那些重复的数值即会出现在a[i] != i的位置处。 例子：[2, 3, 1, 0, 2, 5, 3]; 物归原主后：[0, 1, 2, 3, 2, 5, 3]。 可见，重复的数字：2在i = 4处，3在i = 6处。 当然了，有的题目做了点变体，即a[i]∈[1,n]\in[1, n]∈[1,n]时，则把a[i]放到i = a[i
力扣刷题（数组篇）
weixin_59796310的博客
04-16 991
力扣刷题（数组篇）
LeetCode(力扣）数组题库题解（中等组）（题号11~18)
12-28
LeetCode(力扣）数组题库题解（中等组）（题号11~18) （2023.12.28有更新）（待续） 包括对文章题目的代码文件源码、调试部分，以及PDF的流程图，帮助读者更好的理解和使用，通过简单的代码循序渐进的讲授python部分...
LeetCode(力扣）数组题库题解（简单组）（题号1~88)
12-28
LeetCode(力扣）数组题库题解（简单组）（题号1~88)（2023.12.15有更新）完结 包括对文章题目的代码文件源码、调试部分，以及PDF的流程图，帮助读者更好的理解和使用，通过简单的代码循序渐进的讲授python部分知识，...
LeetCode(力扣）数组题库题解（简单组）（题号108~121)
12-28
LeetCode(力扣）数组题库题解（简单组）（题号108~121)（2023.12.28有更新）待续 包括对文章题目的代码文件源码、调试部分，以及PDF的流程图，帮助读者更好的理解和使用，通过简单的代码循序渐进的讲授python部分...
【力扣刷题】数组-链表-哈希-双指针
06-21
"数组-链表-哈希-双指针" 在计算机科学中，数组是一种基本的数据结构，用于存储相同类型的数据元素。数组中的每个元素都可以通过下标索引来访问，下标从0开始计数。数组的元素是不能删除的，只能覆盖。不能释放单个...
LeetCode:力扣习题库
04-04
力扣（LeetCode）是一个非常受欢迎的在线编程挑战平台，专为提升算法技能和准备技术面试而设计。这个平台提供了大量的编程题目，涵盖了多种编程语言，包括C++。在这个“LeetCode--”压缩包文件中，很可能是包含了与...
LeetCode热题100刷题5：189. 轮转数组、238. 除自身以外数组的乘积、41. 缺失的第一个正数
cir_sky的博客
07-03 220
数组篇，今天的三道题略简单
刷leetcode中常用且有效的方法总结
最新发布
路有瑶台的博客
07-04 259
刷题的时候经常会因为不知道一个方法多写很多行代码，既然有trick为何不用！你问我眼中为何常含泪水，因为我忘记方法忘的深沉。join（）是 Python 中的一个字符串方法，它用于将序列（如列表、元组、集合等，但集合需要首先转换为列表或其他有序序列，因为集合是无序的）中的元素以指定的字符连接生成一个新的字符串。方法来更新计数器中的计数。可以传递另一个可迭代对象或者另一个。提供了一个快速简单的方式来统计哈希对象在集合中出现的次数。
Java | Leetcode Java题解之第212题单词搜索II
m0_57195758的博客
07-03 348
Java | Leetcode Java题解之第212题单词搜索II
[Leetcode 136][Easy]-只出现一次的数字
2201_75413354的博客
07-03 198
②后面研究，发现对于对于查找数组中唯一一个出现一次的元素，我们更适合使用线性扫描和位操作的方法。异或运算满足交换律，且一个数异或自己结果是0，一个数异或0结果是自己。因此把数组中所有元素进行异或运算，得到结果是唯一数。①首先看到数组中重复的数字，想到快慢指针，但是数组的元素是乱序的不好求。使用了STL库的sort函数，时间复杂度O(nlogn)不符合题目要求，空间复杂度O(1)。
力扣 两数组的交集用C语言实现
04-24
请问您需要的是两个数组的交集元素还是交集元素的数量？ 如果是交集元素，可以采用双指针的方式，先将两个数组排序，然后设定两个指针 i 和 j，分别指向两个数组的开头，比较两个指针所指向的元素的大小，如果相等...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值