代码随想录算法训练营第一天| 有序数组的平方 ，长度最小的子数组，螺旋矩阵II

第二天，题目变多，一开始想在值在原容器中进行，但发现，问题有点多，后新开一个容器，完成。

    vector<int> sortedSquares(vector<int>& nums) {
        //递增
        int left ,right;  
        int size=nums.size();
        for(int i=0;i<size;i++){
            nums[i]=nums[i]*nums[i];
        }
        vector<int> return_nums(size);
        int return_index=size-1;
        left=0;
        right=size-1;
        

                //从大到小，小到大，最大的容易找。
        while(left<=right){
            if(nums[right]<nums[left]){
                return_nums[return_index--]=nums[left++];
            }
            else{
                return_nums[return_index--]=nums[right--];
            }
        }
        return return_nums;
    }

下面这一题，想了好久都没有想出来，暴力也没哈 看了视频，采用平滑窗口的方式，OK

    int minSubArrayLen(int target, vector<int>& nums) {
        
        int size=nums.size();
        int mini_len=size+1;
        int first,last;
        int cur_sum=0;
        first=0;
        last=0;
        //采用滑动窗口的办法，主要是判断起点
        while(last<size){
            if(first==last){
                cur_sum=nums[last];
                if(cur_sum>=target){
                    mini_len=1;
                    break;
                }
                last++;
            }
            else{
                cur_sum+=nums[last];
                if(cur_sum>=target){
                     if((last-first+1)<mini_len){
                         mini_len=(last-first+1);
                     }
                    cur_sum-=nums[first++]; 
                    cur_sum-=nums[last]; 
                    continue;      
                }
                else{
                     last++;
                }
            }
        }
        if(mini_len==size+1){
            mini_len=0;
        }
        return mini_len;
    }

第三题，是没有头绪，看级别是简单，有点惭愧。有点暴力

    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> return_vector_2(n, vector<int>(n));
        //先初始化一个数组  上 右
        int mid=n/2;
        int real_value=1;
        int i,j,k;
        int row_num=0;
        for(;row_num<mid;row_num++){
            int offset=n-1-row_num;
            i=row_num;
            for(j=row_num;j<offset;j++){
                return_vector_2[i][j]=real_value++;
            }
            for(i=row_num;i<offset;i++){
                return_vector_2[i][j]=real_value++;
            }
           for(j=offset;j>row_num;j--){
                return_vector_2[i][j]=real_value++;
            }
            for(i=offset;i>row_num;i--){
                return_vector_2[i][j]=real_value++;
            }
        }
        if(n%2==1){
            return_vector_2[mid][mid]=real_value;
        }
        return return_vector_2;
    }