Day2 977.有序数组的平方 ，209.长度最小的子数组 ，59.螺旋矩阵II ，总结

Day2 :

有序数组的平方：

977. 有序数组的平方 - 力扣（LeetCode）

第一种暴力解法：

将数组中元素先平方再进行排序。这样时间复杂度为nlogn。

class Solution
{
	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；
	}
};

第二种解法：双指针解法：

主要思想是因为数组中肯定包含的有负数，所以需要分别从数组的两头进行取值，由于是升序排列所以需要

新数组的新下标要从数组的最后一个进行。

class Solution
{
 	int sortedSquare(vector<int>& nums)
    {
        int k = nums.size()-1;//定义新数组的下标
        int i = 0;
        int j=nums.size()-1;
        vector<int> result(nums.size());
        for(i,j;i<=j;)
        {
            if(nums[i]*nums[i]>nums[j]*nums[j])
            {
                result[k] = nums[i]*nums[i];
                k--;
                i++;
			}
           	else
            {
                result[k] = nums[j]*nums[j];
                k--;
			}
		}
        return reslut;
	}
};

209. 长度最小的子数组

暴力解法：步思想是找到所有的子区间两个for循环解决问题。

双指针即滑动窗口解决长度最小的子数组：

class Solution
{
    int minSubArrayLen(int target,vector<int>&nums)
    {
        int i=0;
        int j=0;//定义滑动窗口的末位置
        int result =nums.size()+1;//自己定义一个合适的初始值最后再筛选一下
        int sum=0;//定义求和值
        for(int j=0;j<nums.size();j++)//末尾值进行遍历
        {
            sum +=nums[j];//求和值
            while(sum>=target)//寻找大于等于目标值的最小子数组
            {
                minSubarrL = j-i+1;//计算子数组长度
                result = min(result,minsubarrL);//取最小值
                i++;//向后遍历找最小子数组
			}
		}
        if(result<=nums.size())//最后再筛选一下
        {
            return result;
		}
        else
        {
            return 0;
		}
	}
};

核心思想：

终止位置的选择和初始位置是怎么进行选择的才能达到选择到最小子数组的目的。

59. 螺旋矩阵 II

这个题目多注意边界处理即可参考二分法

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        int loop = n/2;
        int startx = 0;//起始行位置
        int starty = 0;//起始列位置
        int count = 1;//计数处理进行填充
        int offset=1;//先处理边界值
        vector<vector<int>> matrix(n,vector<int>(n, 0));
        int i=0;
        int j=0;
        while(loop--)
        {
            i = startx;
            j = starty;
            for(j;j<n-offset;j++)//int a[i][j]先处理列；
                {
                    matrix[startx][j]=count;
                    count++;
                }
            for(i;i<n-offset;i++)
                {
                    matrix[i][j]=count;
                    count++;
                }
            for(j;j>startx;j--)
                {
                    matrix[i][j]=count;
                    count++;
                }
            for(i;i>starty;i--)
                {
                    matrix[i][j]=count;
                    count++;
                }
            startx++;
            starty++;
            offset++;
            
        }
        if(n%2)
            {
                matrix[n/2][n/2]=count;
            } 
        return matrix;    
    }
};

数组理论总结：