力扣刷题数组篇（704.二分查找，27. 移除元素，977.有序数组的平方，209.长度最小的子数组，，59.螺旋矩阵II）（所用方法二分查找法，双指针法，滑动窗口法，模拟过程法）

704.二分查找

力扣题目链接

题目

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

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9     
输出: 4       
解释: 9 出现在 nums 中并且下标为 4     

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2     
输出: -1        
解释: 2 不存在 nums 中因此返回 -1       

思路

题目说明了数组是有序的，并且无重复元素，因为一旦有重复元素，使用二分查找法返回的元素下标可能不是唯一的，这些都是使用二分法的前提条件。

而二分法主要是在边界问题上会出现错误，只要我们保证自己每次搜寻的区间定义相同（比如一种是前闭后闭的区间，一种是前闭后开的区间。

我主要写的是一种前闭后闭的区间。

我们定义上述区间为一个前闭后闭的区间也就是[left,right],这样我们在判断退出循环的条件也就是left<=right，因为left=rigth在前闭后闭的区间也是有意义的；

mid=left+(right-left)/2（相比于直接写(left+right)/2来说是为了防止溢出）

循环的语句：if(nums[mid]>val) left=mid+1; else if(nums[mid]<val) right=mid-1; else return mid;

整体代码如下：

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int num= nums.size()-1;//右值
        int left=0;//左值
        while(left<=num)
        {
            int middle=left+(num-left)/2;
            if(nums[middle]>target)
            {
                num=middle-1;

            }
            else if(nums[middle]<target)
            {
                left=middle+1;
            }
            else 
            {
                return middle;
            }
        }
        return -1;

    }
};

27. 移除元素

题目

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

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

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

示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。

示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

你不需要考虑数组中超出新长度后面的元素。

力扣题目链接

思路

如果该题直接用暴力解法也就是双循环，外循环找到要删除的值，内循环进行删除也就时将后续的数组将前面的数组覆盖。

那样得到的结果其时间复杂度为o（n²），在力扣上也是能通过的，但是我们得放开思路学习一些别的解法，用简单的题目将思维放开使用不同的方法去解答，这样才能在难的题目上从容一点。

如果我们选择使用双指针法，双指针法在链表和数组的题目中是较为常见的一种解法，并且它的时间复杂度往往是o（n）的量级。

而这题使用双指针去求解，也就是一个快指针一个慢指针，快指针去寻找val值，当找到val==快指针时，快指针++，而慢指针不变，一直到快指针！=val时，将快指针指向的值赋给慢指针并且快指针和慢指针都同时自增;

其时间复杂度为o（n）；

其整体代码如下：

class Solution
 {
public:
    int removeElement(vector<int>& nums, int val)
     {
        int size=nums.size();
        int slow =0 ;
        int fast=0;
        while(fast<size)
        {
            //快指针！=val时，将快指针指向的值赋给慢指针并且快指针和慢指针都同时自增;
            if(nums[fast]!=val)
            {
                nums[slow]=nums[fast];
                fast++;
                slow++;

            }
            else
                fast++;//当找到val==快指针时，快指针++，而慢指针不变
        }
        return 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]

示例 2： 输入：nums = [-7,-3,2,3,11] 输出：[4,9,9,49,121]

思路

• 暴力解法：先对数组中的数字先平方，然后在排序，这样的时间复杂度是o（n+nlog n）

• 双纸指针解法：数组是有序的，就是可能存在负数，而负数平方后可能比小的正数大，但是因为数组时有序的，所以较大的平方数只可能存在两端，这样我们双指针求解时，一端指向头部，一端指向尾部，只需要比较他们的大小就可以将数组排序成功，时间复杂度为o（n）；

整体代码

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) 
    {
        vector<int>num(nums.size(),1);
        int k=nums.size()-1;
        int i=0;
        int j=nums.size()-1;
        while(i<=j)
        {
            //如果头部元素大于尾部则将头部元素插入到新数组，并将当前数组的尾部前移与头部元素再对比
            if(nums[i]*nums[i]<nums[j]*nums[j])
            {
                num[k]=nums[j]*nums[j];
                j--;
                k--;
            }
            else
            {
                 //如果尾部元素大于头部则将尾部元素插入到新数组，并将当前数组的头部后移与尾部元素再对比
                num[k]=nums[i]*nums[i];
                i++;
                k--;
            }
        }
        return num;
                

    }
};

209.长度最小的子数组

题目

力扣题目链接

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

示例：

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

思路

滑动窗口解法：滑动窗口的思想就是不断调节起始位置和终止位置，使得区间内的结果是我们想要的。

滑动窗口主要确定有三点：
窗口内的区间是什么？

起始位置应该如何去移动？

末尾位置应该如何去移动？（也就是什么条件让他去移动）

窗口就是：满足其和 ≥ s 的长度最小的 连续 子数组。

窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是区间缩小了）。

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，窗口的起始位置设置为数组的起始位置就可以了。

整体代码

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums)
    {
        int cur;//末尾位置
        int pre=0;//起始位置
        int sum=0;//数组和
        int length=0;//长度
        int result =INT32_MAX;

        for(cur=0;cur<nums.size();cur++)
        {
            sum+=nums[cur];
            //while((sum+=nums[cur])>=target)//当cur=3的时候回一直+3产生循环，不会cur++
            while(sum>=target)
            {
                length=cur-pre+1;
                result=result>length?length:result;
                sum-=nums[pre];
                pre++;
                
            }
        }
        return result==INT32_MAX?0:result;
        

    }
};

59.螺旋矩阵II

题目

力扣题目链接

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

示例:

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

思路

这题主要是找规律，如何找到相同的循环区间，如果不考虑清楚就直接写的话，可能在后续运行时遇到各种问题，然后进行各种修改。

我们对该题的思路首先可以找出的规律就是：

数字的添加：上—从左至右

​ 右—从上到下

​ 下—从右到做

​ 左—从下到上

其中在4个循环中，我们可以找到的规律是遍历的长度都是相等的，并且在从上行到右列的拐角处我们可以看出，右列的循环为上行的列数不变行数叠加；而这样的规律我们就可以将4个循环给链接起来；

整体代码如下

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        int start_x=0;//起始X
        int start_y=0;//起始Y
        int circle=n/2;//循环计数
        int offset=n;//循环遍历长度
        int count=1;//计数器
        int i,j;
        
        vector<vector<int>>nums(n,vector<int>(n));
        while(circle--)
        {
            for(j=start_y;j<offset-1;j++)
                nums[start_x][j]=count++;
            for(i=start_x;i<offset-1;i++)
                nums[i][j]=count++;
            for(j;j>start_y;j--)
                nums[i][j]=count++;
            for(i;i>start_x;i--)
                nums[i][j]=count++;
            start_y++;
            start_x++;
            offset=offset-1;
            
        
        }
        if(n%2==1)
            nums[n/2][n/2]=count;
        
        return nums;

    }
};