刷题day2| 977.有序数组平方 209.长度最小数组，59.螺旋矩阵||

love-lalisa

已于 2022-10-28 17:07:08 修改

阅读量409

点赞数

分类专栏：力扣数据结构文章标签：算法 leetcode

于 2022-10-27 21:32:56 首次发布

本文链接：https://blog.csdn.net/weixin_53148080/article/details/127561238

版权

力扣同时被 2 个专栏收录

14 篇文章 0 订阅

订阅专栏

数据结构

6 篇文章 0 订阅

订阅专栏

数组的排序

可以直接调用如下的方法

sort(nums.begin(),nums.end());

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]

题解

1.暴力解法

一开始还用辅助数字来暴力，其实直接遍历将每个平方之后，进行排序就好了

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        //暴力法

     for(int i = 0;i < nums.size(); i++){
         nums[i] = nums[i] * nums[i];
     }
     sort(nums.begin(),nums.end());
     return nums;
    }
};

2.双指针法

非递减的整数序列，主要考察的是：负数的平方可能比整数大

而且要利用非递减数组的特性，一般俩边值都很大，中间值很小

所以可以逆序的更新新数组

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
       int i = 0, j = nums.size() - 1;
       vector<int> temp(nums.size());
       int k = nums.size() - 1;

       while(i <= j){
           if(nums[i] * nums[i] > nums[j] * nums[j]){
               temp[k] = nums[i] * nums[i];
               k--;
               i++;
           }
           else{
               temp[k] = nums[j] * nums[j];
               k--;
               j--;
           }
       }
       return temp;

    }
};

209.长度最小的子数组

题目

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例 1：

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

输入：target = 4, nums = [1,4,4]
输出：1
示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

题解

1.暴力解法【目前力扣已经超时了】

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        //暴力法
        int i = 0,j = 0;
        int sum = 0;
        int len = INT32_MAX;
        int subLength = 0;
        for(int i = 0;i < nums.size(); i ++){
            sum = 0;
            for(int j = i;j < nums.size();j++){
                sum += nums[j];
                if(sum >= target){
                   subLength = j - i + 1;
                   len =len > subLength?subLength:len;
                     break;
                }
                //如果sum += nums[j]写在这里的话，sum是上次循环里加的值，此时 j已经++了，算出来的序列长度比正确答案长
            }
        }
        return len == INT32_MAX ? 0 :len;  //看len有没有被赋值，没有的话说明没有找到符合条件的子序列
    }
};

2.滑动窗口

滑动窗口对于寻找满足条件的子序列非常有用，实现滑动窗口通常是通过双指针来维护窗口的起始位置和结束位置

//最重要的思路就是以终止位置作为for循环中的循环体，不断调节起始位置的值

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
             
       //连续子数组、连续子序列
       //我们要想到滑动窗口
       int start = 0,end = 0;
       int result = INT32_MAX;
       int len = 0;
       int sum = 0;
       //我们要不断变更滑动窗口起始位置
       for(end = 0;end < nums.size(); end++){
         sum += nums[end];

         while(sum >= target){  //这里必须要用while用if的话 减一次sum还有可能大于 target
             len = end - start + 1 ;
             result = len < result? len:result;
             sum -= nums[start]; //精髓，不断的移动起始点的位置
             start++;
         }
     
    }
         return result == INT32_MAX ? 0 : result;
    }
};

59.螺旋矩阵||

题目

在这里插入图片描述

题解

这道题目主要就是模拟

模拟顺时针画螺旋矩阵的过程

最重要的是边界处理，填充矩阵也要有一个原则

eg：左闭右开的原则，即遇到拐角，我们先不处理，在下一次模拟的时候当作左边来处理

疑惑的是中间这一行怎么处理，可以发现：

当n为奇数，中间只有一个值，需要单独赋值

n为偶数时候，中间有一行值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-etw2zQLl-1666877491325)(C:\Users\dell\Desktop\20220922102236.png)]

模拟的时候，我们要模拟到所有情况，可以模拟一个偶数，一个奇数，并且要模拟到有多圈的情况

可以画个示例图，根据图来写代码

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
       
       vector<vector<int>> result(n,vector<int>(n,0));
       int startx = 0 ,starty = 0;//要定义填充的起始位置和结束位置
       
       int loop = n / 2; //循环圈数，n为基数，中间一值需要特殊赋值，偶数的话，按圈来赋值
       int offset = 1; //一圈循环完之后。遍历的长度也会缩短

       int count = 1; //用来赋值;
       int i ,j;
       //我们这里定义一个左闭右开的原则
        while(loop--){
             i = startx;
             j = starty;  //一圈循环完之后 startx 和 starty会改变 【0，0】 变为【1，1】
            
          //从左向右
         for(j = starty;j < n - offset;j++){
             result[startx][j] = count;
             count++;
         }

          //从上往下
           for(i = startx;i < n -offset;i ++){
           result[i][j]  = count;
           count++; 
           }

         //从右往左
         for(;j > starty;j--){
             result[i][j] =count;
             count++;
         }

         //从下往上

         for(;i > startx; i --){
             result[i][j] = count;
             count++;
         }
            
            //进入下一圈
            startx++;
            starty++;
            
            offset++;
        }
        
        //如果n为奇数，要单独的给最中间赋值
        if(n % 2 != 0){
           result[n / 2][ n / 2] = n * n;
        }


        return result;
    }
};