代码随想录Day2——997.有序数组的平方 209.长度最小的子数组 59.螺旋矩阵

一.997有序数组的平方

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

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int frontpoint = 0;
        int behindpoint = nums.size()-1;
        vector<int>  temp;
        temp.resize(nums.size());
        int i = nums.size()-1;
        while(behindpoint>=frontpoint)
        {
            if(abs(nums[frontpoint])>abs(nums[behindpoint]))
            {
                temp[i--] = nums[frontpoint]*nums[frontpoint];
                frontpoint++;
            }
            else
            {
                temp[i--] = nums[behindpoint]*nums[behindpoint];
                behindpoint--;
            }
        }
        return temp;
    }
};

1. vector容器重新定义容器大小resize，多出来的数据直接删除，少的数据用0补充，声明时定义容器大小vector<int> result(num, 0)
2. 双指针法的另一种用法--前后指针，上一篇博客Day1中有用快慢指针，接下来一个题目用到滑动窗口，其本质也是双指针

二.209长度最小的子数组

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

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

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int frontpoint = 0;
        int behindpoint = 0;
        int temp = 0;
        int result = 100001;
        int sum = 0;
        int flag = 0;
        //暴力解，但是超时
        //result = nums.size()
        /*for(int i = 0;i< nums.size();i++)
        {
            sum = sum + nums[i];
        }
        if(sum<target)
            return 0;
        while(frontpoint < nums.size())
        {
            sum = nums[frontpoint];
            if(sum >= target)
                return 1;
            behindpoint = frontpoint + 1;
            temp = 1;
            while(behindpoint < nums.size())
            {
                sum = sum + nums[behindpoint];
                temp++;
                behindpoint++;
                if(sum >= target)
                result = min(temp,result);
            }
            frontpoint++;
        }*/
        //my_滑动窗口
        //result = 0;
        /*while(behindpoint < nums.size())
        {
            sum = flag?(sum + nums[behindpoint]-nums[frontpoint-1]):(sum + nums[behindpoint]);
            temp = flag?(temp):(temp+1);
            if(sum >= target)
            {
                flag = 1;
                result = temp;
                while(frontpoint<behindpoint)
                {
                    sum = sum - nums[frontpoint];
                    temp--;
                    frontpoint++;
                    if(sum < target)
                        break;
                    result = temp;
                }
            } 
            if(flag == 0)
                behindpoint++;
            else
            {
                behindpoint++;
                frontpoint++;
            }
        }
        return result;*/
        //代码随想录滑动窗口
        while(behindpoint < nums.size())
        {
            
            sum = sum + nums[behindpoint];
            while(sum>=target)
            {
                temp = behindpoint - frontpoint + 1;
                sum = sum - nums[frontpoint];
                frontpoint++;
                result = min(temp,result);
            }
            behindpoint++;//加一的位置很重要
        }
        return (result == 100001)?0:result;
    }
};

1. my_滑动窗口，后边的指针先不断移动，满足条件后起始指针移动，得到满足条件的序列，之后两个指针同时向后移动，因为只需要考虑有无更小的序列，迭代得到最短序列
2. 代码随想录滑动窗口：后边的指针先不断移动，满足条件后起始指针移动，得到满足条件的序列，之后起始指针不动终止指针继续向后移动，迭代并比较得到最短序列，图来源：代码随想录 (programmercarl.com)
3. 使用while和for循环的区别：注意while计数值在什么位置加或者减

三.59.螺旋矩阵

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

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> result(n, vector<int>(n, 0));
        int half = n/2;
        int c = 1;
        int j,p,q,m;
        if(n%2 == 1)
            result[half][half] = n*n;
        for(int i = 0;i<half;i++)
        {
            for(j = i;j<n-1;j++)
            {
                result[i][j] = c++;
            }
            for(p = i;p<n-1;p++)
            {
                result[p][j] = c++;
            }
            for(q = n-1;q>i;q--)
            {
                result[p][q] = c++;
            }
            for(m = n-1;m>i;m--)
            {
                result[m][q] = c++;
            }
            n--;
        }
        return result;
    }
};

1. 用容器定义二维数组的方式​​​​​​​ vector<vector<int>> result(n, vector<int>(n, 0));
2. 逻辑问题：考虑转几圈，奇数的话最后不转一圈，将最后一个数填充到最中间，每转一圈每行（列）的起始位置和终止位置都需要减一；区间开闭要保持统一。