【代码随想录】Day1&2数组：力扣704，35，34，27，977，209，59

目录

基本知识

二分法

思路

例题：力扣704

练习1：力扣35 已完成

练习2：力扣34 已完成

练习3：力扣69

练习4：力扣367

双指针法

思路

例题：力扣27

例题：力扣977

练习1：力扣26 

练习2：力扣283 

练习3：力扣844

滑动窗口

思路

例题：力扣209

练习1：力扣904 

练习2：力扣76

模拟行为

思路:

例题：力扣59

基本知识

1.数组是存放在连续内存空间上的相同类型数据的集合。

• 数组下标都是从0开始的。
• 数组内存空间的地址是连续的

2.因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。

3.数组的元素是不能删的，只能覆盖。

二分法

思路

①前提是数组为有序数组，同时题目还强调数组中无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的，这些都是使用二分法的前提条件。

②while (left <= right) 要使用 <= ，因为left == right是有意义的，所以使用 <

③if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1

例题：力扣704

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left=0;
        int right=nums.size()-1;
        int middle=(left+right)/2;
        while(left<=right){ //在循环内部 当left==right，区间[left, right]依然有效，所以用 <=
            if(target>nums[middle]){
                left=middle+1;
            }
            else if(target<nums[middle]){
                right=middle-1;
            }
            else if(target==nums[middle]){
                return middle;
            }
            middle=(left+right)/2;
        }
        return -1;
    }
};

练习1：力扣35 已完成

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        //暴力解法
        /*
        for(int i=0;i<nums.size();i++){ 
            if(target<=nums[i]){ //一旦发现大于或者等于target的num[i]，那么i就是我们要的结果
                return i;
            }
            
        }
        return nums.size();*/
        //二分法解法
        int left=0;
        int n=nums.size();
        int right=n-1;
        while(left<=right){
            int middle=(left+right)/2;
            if(target==nums[middle]){
                return middle;
            }
            else if(target<nums[middle]){
                right=middle-1;
            }
            else if(target>nums[middle]){
                left=middle+1;
            }
        }
        return right+1;
    }
};

练习2：力扣34 已完成

给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。

class Solution {
public:
//情况一：target 在数组范围的右边或者左边，例如数组{3, 4, 5}，target为2或者数组{3, 4, 5},target为6，此时应该返回{-1, -1}
//情况二：target 在数组范围中，且数组中不存在target，例如数组{3,6,7},target为5，此时应该返回{-1, -1}
//情况三：target 在数组范围中，且数组中存在target，例如数组{3,6,7},target为6，此时应该返回{1, 1}
    vector<int> searchRange(vector<int>& nums, int target) {
        int rightborder=searchRight(nums,target);
        int leftborder=searchLeft(nums,target);
        //情况一
        if(rightborder==-2||leftborder==-2) return{-1,-1};
        //情况三
        else if(rightborder-leftborder>1) return{leftborder+1,rightborder-1};
        //情况二
        else return{-1,-1};
    }

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

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

练习3：力扣69 已完成

给你一个非负整数 x ，计算并返回 x 的 算术平方根 。

由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。

注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

class Solution {
public:
    int mySqrt(int x) {
        //暴力求解
       /* long long int res=0; //数据类型改为long long 
        for(long long int i=1;i<=x;i++){ //注意数据类型如果是int会爆开
            if(i*i<=x&&(i+1)*(i+1)>x){
                res=i;
                break;
            }
        }
        return res;*/

        //二分法求解
        //处理特殊值
        if(x==1||x==0){
            return x;
        }
        int left=0;
        int right=x;
        int mid=0;
        while(left<=right){
            mid=(right+left)/2;
            if(x/mid>mid){
                left=mid+1;
            }
            else if(x/mid<mid){
                right=mid-1;
            }
            else
                return mid; //能整除，返回中间值
        }
        return right;//左边更小
    }
};

练习4：力扣367 已完成

给定一个 正整数 num ，编写一个函数，如果 num 是一个完全平方数，则返回 true ，否则返回 false 。

进阶：不要 使用任何内置的库函数，如  sqrt 。

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

双指针法

思路

通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

• 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
• 慢指针：指向更新 新数组下标的位置

例题：力扣27

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        //暴力法求解
        /*int n=nums.size();
        int count=0;
        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--; //因为下标为i的数字都向前移动了一位 所以下标也向前移动一位
                n--;//数组的大小也-1
            }
        }
        return n;*/
        //双指针法
        int slow=0;//慢指针，指向新的元素
        int fast=0;//快指针，指向原来的数组
        for(fast=0;fast<nums.size();fast++){
            if(nums[fast]!=val){ //值不为要找到的元素
                nums[slow]=nums[fast]; //fast的值覆盖掉slow的值 
                slow++; //slow向后走一位 数组下标移动
            }
        }
        return slow; //按理说slow已经++过，原本的大小应该少一个，但由于是从0开始，所以刚好事slow的大小，直接输出即可
    }
};

例题：力扣977

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。

示例 1： 输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        //暴力解法 时间复杂度O(n + nlogn) 取决于快排的时间复杂度O(n)
       /* int n=nums.size();
        for(int i=0;i<n;i++){
            nums[i]=nums[i]*nums[i];
        }
        sort(nums.begin(),nums.end());
        return nums;*/
        int n=nums.size();
        int i=0; //头指针
        int j=n-1; //尾指针
        int k=n-1;//新数组的指针 指向最后一位事由于要从小到大进行排序
        vector<int> result(nums.size(),0); //注意vector的用法
        for(i=0,j=n-1;i<=j;){
            if(nums[i]*nums[i]>nums[j]*nums[j]){
                result[k]=nums[i]*nums[i];
                i++;
                k--;
            }
            else{
                result[k]=nums[j]*nums[j];
                j--;
                k--;
            }
        }
        return result; //返回新数组即可
    }
};

练习1：力扣26 已完成

给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。

将最终结果插入 nums 的前 k 个位置后返回 k 。

不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int slow=0;
        int n=nums.size();
        if(n<2)
            return n;
        for(int fast=1;fast<n;fast++){
            if(nums[slow]!=nums[fast]){
                nums[++slow]=nums[fast];
            }
        }
        return slow+1; //返回的时候+1就通过了，也不知道是为什么
    }
};

练习2：力扣283 已完成

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int slow=0;
        int n=nums.size();
        for(int fast=0;fast<n;fast++){//往前挪动
            if(nums[fast]!=0){
                nums[slow]=nums[fast];
                slow++;
            }
        }
        for(int i=slow;i<n;i++){ //把后面补零
            nums[i]=0;
        }
    }
};

练习3：力扣844

给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

注意：如果对空文本输入退格字符，文本继续为空。

滑动窗口

思路

不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

①窗口内是什么

满足其和 ≥ s 的长度最小的 连续 子数组

②如何移动窗口的起始位置

如果当前窗口的值大于s了，窗口就要向前移动了

③如何移动窗口的结束位置

窗口的结束位置就是遍历数组的指针，也就是for循环里的索引

例题：力扣209

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

输入：s = 7, nums = [2,3,1,2,4,3] 输出：2 解释：子数组 [4,3] 是该条件下的长度最小的子数组。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) { 
        //暴力算法 运行超时 O（n^2）
        /*int sum=0;
        int subl=0;
        int res=INT32_MAX;
        for(int i=0;i<nums.size();i++){
            sum=0;
            for(int j=i;j<nums.size();j++){
                sum+=nums[j];
                if(sum>=target){
                    subl=j-i+1;
                    res=min(subl,res);
                    break;
                }
            }
        }
        return res==INT32_MAX?0:res;*/

        //滑动窗口
        int i=0;
        int sum=0;
        int res=INT32_MAX;
        int subl=0;
        for(int j=0;j<nums.size();j++){ //j表示滑动窗口的末尾位置
            sum+=nums[j];
            while(sum>=target){ //当从头开始累加到某一个特定位置的时候，恰好满足条件，尝试从头减去
                subl=j-i+1;
                res=min(res,subl);
                sum-=nums[i]; //从头开始减
                i++;//窗口向后移动
            }
        }
        return res==INT32_MAX?0:res;
    }
};

练习1：力扣904 

练习2：力扣76

模拟行为

思路:

模拟顺时针画矩阵的过程:

1	2	3
8	9	4
7	6	5

• 填充上行从左到右
• 填充右列从上到下
• 填充下行从右到左
• 填充左列从下到上

由外向内一圈一圈这么画下去，每条边左闭右开的原则

例题：力扣59

给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

示例:输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0)); // 使用vector定义一个二维数组
        //重要原则：左闭右开
        int i,j;
        int startx=0;
        int straty=0;
        int offset=1;
        int loop=n/2;
        int count=1;
        while(loop--){
            //左到右
            for(j=straty;j<n-offset;j++){
                res[startx][j]=count++;
            }
            //上到下
            for(i=startx;i<n-offset;i++){
                res[i][j]=count++;
            }
            //右到左
            for(;j>straty;j--){
                res[i][j]=count++;
            }
            //下到上
            for(;i>startx;i--){
                res[i][j]=count++;
            }
            startx++;
            straty++;
            offset++;
        }
    if(n%2==1){
        res[n/2][n/2]=count;
    }
    return res;
    }
};

练习1：力扣54 

练习2：剑指Offer 29