代码随想录day2|数组与双指针进阶（977+209+59）

977 有序数组的平方

链接：https://leetcode.cn/problems/squares-of-a-sorted-array/description/

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

方式一：暴力求解 O（nlogn）

// c++暴力实现
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int len=nums.size();
        vector<int> res(len);
        for(int i=0;i<len;i++){
            res[i]=pow(nums[i],2);
        }
        sort(res.begin(), res.end());
        return res;
    }
};

方式二：变相有序数组的合并 --双指针 O（n）

• 思路

  • 相当于合并两个非递减序列，使合并后的序列仍是非递减序列

  • 找到最小平方数的索引位置，其左右两边的数作为两个非递增序列，每次取最小的元素加入结果数组，当有一个序列遍历结束，则将另一个序列依次加入结果序列即可

• 关键点
  • 利用双指针进行元素比较，遍历序列
  • 边界判断

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int len=nums.size();
        int minad=len+1;//最小平方数的索引位置
        int minn=1e4+1;
        vector<int> pownums(len);
        for(int i=0;i<len;i++){
            pownums[i]=pow(nums[i],2);
        } 
        vector<int> res(len);
        if(nums[0]>=0&& nums[len-1]>=0){//全正 平方后数组也为非递减顺序
            return pownums;
        }
        else if(nums[0]<=0&& nums[len-1]<=0){//全负 平方后数组为递减顺序
            reverse(pownums.begin(),pownums.end());
            res=pownums;//取逆序
            return res;
        }
        else{//有正有负
            //找到最小平方数所在的位置
            for(int i=0;i<len;i++){
                int tmp=pownums[i];
                if(tmp<minn){
                    minn=tmp;
                    minad=i;
                }
            }  
            int index=0;//最小平方数的两侧为两个非递减的序列
            int left=minad-1;
            int right=minad+1;
            res[index++]=pownums[minad];
            //合并两个非递减序列，使合并后的序列仍是非递减序列
            while(left>=0 &&right<=len-1){
                if(pownums[left]<=pownums[right]){//将更小的数放入
                    res[index++]=pownums[left--];
                }
                else {
                    res[index++]=pownums[right++];
                }
            }
            if(left==-1){//左序列遍历完
                while(right<len){//右序列依次放入
                    res[index++]=pownums[right++];
                }
             }
            if(right==len){//右序列遍历完
                while(left>=0){//左序列依次放入
                    res[index++]=pownums[left--];
                }
            }
            return res;
        } 
    }
};

209 长度最小的子数组

链接：https://leetcode.cn/problems/minimum-size-subarray-sum/description/

给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

思路：滑动窗口 O(n）

• 左右窗口
  • i：右窗口，遍历数组
  • j：左窗口，满足条件改变窗口大小，左窗口向右移动
• 关键点
  • 左窗口的移动，且将减去元素
  • 虽然是两个循环，但是对于每个元素仅操作了一次，2*O(n),时间复杂度为O(n)。

c++实现：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int len= nums.size();
        int minlen=1e5+1;
        int tmplen=0;
        int j=0,sum=0;
        for(int i=0;i<len;i++){
            sum+=nums[i]; 
            while(sum>=target){  
                tmplen=i-j+1;
                minlen=min(tmplen,minlen);
                sum-=nums[j];
                j++;    
            }   
        }
        if(minlen==1e5+1)return 0;
        else{
            return minlen;
        }
    }
};

59 螺旋矩阵Ⅱ

链接：https://leetcode.cn/problems/spiral-matrix-ii/

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

思路：模拟

• 方向数组
• 时间复杂度为O(n^2)。

c++实现：

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n,vector<int>(n,0));
        int index=1;
        int end=pow(n,2);
        //右 下 左 上
        int direc[4][2] = {{0,1}, {1,0},{0, -1}, {-1,0}};
        int row = 0;
        int col = 0;
        int idx = 0;
        while(index<=end)
        {
            res[row][col] = index ++;//放入值的行 列
            int dx, dy;
            //获取下一个值的方向
            dx = direc[idx][0];
            dy = direc[idx][1];
            //下一个值的 行列
            int r = row + dx;
            int c = col + dy;
            //去判断是否需要换方向 ①四周边界 ②已放入位置
            if(r <0 || c <0 || r > n-1 || c > n-1 || res[r][c] >0)
            {
                idx = (idx + 1)% 4;
                dx = direc[idx][0];
                dy = direc[idx][1];
            }
            //确认好的行列
            row += dx;
            col += dy;
        }
        return res;
    }
};