day-1 - day-2 代码随想录算法训练营（19期）已二刷

djykkkkkk

已于 2023-09-07 10:10:36 修改

阅读量1.3k

点赞数

分类专栏： # 代码随想录算法训练营（19）文章标签： c++ 算法 leetcode

于 2023-07-26 14:15:20 首次发布

本文链接：https://blog.csdn.net/Ricardo_XIAOHAO/article/details/131937038

版权

代码随想录算法训练营（19）专栏收录该内容

61 篇文章 0 订阅

订阅专栏

704.二分查找

1.分析：有序数组查找目标值，找到返回下标，没找到返回-1

思路一：二分查找

感觉掌握的不太熟练，边界问题调试了多次

class Solution {
public:
    int search(vector<int>& nums, int target) {
        //分析：有序数组查找目标值   二分查找
        //思路：left   mid  right
        if(nums.empty())
            return -1;
        int n=nums.size();
        int left=0,right=n-1,mid=0;
        while(left<=right)
        {
            if(nums[left]==target)
                return left;
            if(nums[right]==target)
                return right;
            mid=(left+right)/2;
            if(nums[mid]==target)
                return mid;
            else if(nums[mid]>target)
                right=mid-1;
            else
                left=mid+1;
        }
        return -1;
    }
};

思路二：直接遍历

class Solution {
public:
    int search(vector<int>& nums, int target) {
        //分析：有序数组查找目标值   二分查找
        //思路：left   mid  right
        //思路二：
        for(int i=0;i<nums.size();i++)
        {
            if(nums[i]==target)
                return i;
            if(nums[i]>target)
                break;
        }
        return -1;
    }
};

看完题解：

class Solution {
public:
    int search(vector<int>& nums, int target) {
        //左闭右开
        int l=0,r=nums.size(),mid=0;
        while(l<r)
        {
            cout<<nums[mid];
            mid=l+(r-l)/2;
            if(nums[mid]>target)
                r=mid;
            else if(nums[mid]<target)
                l=mid+1;
            else
                return mid;
        }
        return -1;
    }
};

可能时环境吵的原因看起来没啥感觉，记下来了取右边界为空时left和right不能相等

二刷分析：左闭右开和左闭右闭

左闭右开：

右边界为nums.size()，是不包含的
在处理left和right的关系上，是left<right
在右边界改变的时候，right=mid（因为下标mid已经不成立了，所以直接成为右边界）

左闭右闭：

右边界为nums.size()-1，是包含的
在处理left和right时，left<=right
在右边界改变时，right=mid-1（因为右边界包含，mid已经不成立了）

三刷分析：

右边的开闭在于取不取right
- 取 right :right更新为mid-1，因为mid已经判断过了，下一步不需要判断；同时left存在==right的情况，因为如果取到最后才能找到结果，最后只剩两个结果的时候，无论left还是right变化都会在left==right的情况下判断。
- 不取right：right更新为mid，同理，下一步不需判断，还需判断 mid-1；同时存在left！=right，因为right永远取不到，取到的时候上一步就结束了。

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

35.搜索插入位置

分析：找目标值下标

思路一：直接遍历

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

二刷：

思路二：二分查找

1.找到目标值直接返回下标

2.找不到目标值：

（1）目标值在两个数中间：不管left和right怎么取，最后绝对取到比目标值小的那一个；因为left和right求中间值，两个连续的数必然四舍五入取小值。所以 return right+1；

（2）目标值在所有数之前：当left=0，right=1时，mid=0 必然是大于目标值，然后right-1，此时left==right，nums[mid]依然大于目标值，right-1。所以 return right+1；

（3）目标值在所有数之后：同理，当left和right在边界时，必然nums [mid] 小于目标值，然后left==right，nums[mid] 依然小于目标值，left=nums.size() ，此时left已经超出边界，所以 return right+1

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

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

思路：双指针分开头尾遍历

class Solution {
public:
//思路：双指针分开左右遍历
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> ans;
        int mid=count(nums.begin(),nums.end(),target);
        if(mid==0)
            return {-1,-1};
        int l=0,r=nums.size()-1;
        while(l<=r)
        {
            if(nums[l]==target)
            {
                ans.push_back(l);
                cout<<l;
                break;
            }
            l++;
        }
        while(r>=l)
        {
            if(nums[r]==target)
            {
                ans.push_back(r);
                cout<<r;
                break;
            }
            r--;
        }
        return ans;
    }
};

27.移除元素

思路一：双层指针（快慢指针）

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

分析:一个从0开始保存不为val的数，一个从0开始找不为val的数

二刷：思路还行，start是下标，所以最后自增正好等于结果个数

977.有序数组的平方

思路：因为是升序，所以平方最大数在两边，双指针两边到中间遍历

class Solution {
public:
    
    vector<int> sortedSquares(vector<int>& nums) {
        int n=nums.size();
        int end=n-1;
        int i=0,j=n-1;
        vector<int>res(n);
        while(i<=j)
            res[end--]=nums[i]*nums[i]>nums[j]*nums[j]?nums[i]*nums[i++]:nums[j]*nums[j--];
        return res;
    }
};

二刷：看了题解hhhhhhh

注意：使用额外空间和额外下标，因为两种情况下左右指针变化不同，与结果下标指针不同步。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n=nums.size();
        vector<int>res(n,0);
        int left=0,r=n-1,right=n-1;
        while(left<=right){
            if(abs(nums[left])>abs(nums[right])){
                res[r]=nums[left]*nums[left];
                left++;
            }else{
                res[r]=nums[right]*nums[right];
                right--;
            }
            r--;
            
        }
        return res;
    }
};

209.长度最小的子数组

思路：滑动窗口，当数组之和大于等于target时，把左边界的值边减去边判断，然后不断更新子数组最小长度

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

二刷路过。

59.螺旋矩阵||

思路：从左到右，从上到下，从右到左，从下到上，只需要打印n/2次

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
       vector<vector<int>> res(n,vector<int>(n,0));
       int i=0,j=0;
       int startx=0,starty=0;//记录变化
       int count=1,loop=n/2,offert=1,mid=n/2;//计数 循环次数 已填充个数 中间值
       while(loop--){

            for(j=starty;j<n-offert;j++)//从左到右遍历填充(注意，for循环中j达到限制条件之后还会++)
                res[startx][j]=count++;
            for(i=startx;i<n-offert;i++)//从上到下
                res[i][j]=count++;
            for(;j>starty;j--)//从右到左
                res[i][j]=count++;
            for(;i>startx;i--)//从下到上
                res[i][j]=count++;
            startx++;
            starty++;
            offert++;
       }
       if(n%2!=0)//因为是起点包含，终点不包含，所以如果是奇数，最后一个数就无法包含并输入
            res[mid][mid]=count;
        return res;
        
    }
};

二刷：

思路：1.打印几圈 2.变化量 3.每次循环都是起点包含，终点不包含

剑指 Offer 59 -I 滑动窗口的最大值

思路：优先队列+滑动窗口维护

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n=nums.size();
        priority_queue<pair<int,int>> que;
        for(int i=0;i<k;i++)//先填满一个滑动窗口
            que.emplace(nums[i],i);
        
        vector<int>res={que.top().first};//直接获取第一个最大值
        for(int i=k;i<n;i++){//往后添加
            que.emplace(nums[i],i);
            while(que.top().second<=i-k)//当前索引i-k+1等于滑动窗口的起始位置
                que.pop();//就是说，最大值已经超出了滑动窗口的位置了
            res.push_back(que.top().first);
        }
        return res;

    }
};

二刷路过

djykkkkkk

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day-1 - day-2 代码随想录算法训练营（19期）已二刷

704. 二分查找、35. 搜索插入位置、34. 在排序数组中查找元素的第一个和最后一个位置、27. 移除元素 977.有序数组的平方 209.长度最小的子数组 59. 螺旋矩阵 II 剑指 Offer 59 -I 滑动窗口的最大值
复制链接

扫一扫