# 代码随想录算法训练营第二天| 977. 有序数组平方、209. 长度最小的子数组、59. 螺旋矩阵II（Java）

代码随想录算法训练营第二天| 977. 有序数组平方、209. 长度最小的子数组、59. 螺旋矩阵II（Java）

977. 有序数组平方

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

code-暴力解

  package com.shuzijun.leetcode.editor.en;
public class SquaresOfASortedArray{
      public static void main(String[] args) {

          Solution solution = new SquaresOfASortedArray().new Solution();
      }
//先生成结果数组，在排序
class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] new_nums=new int[nums.length];
        for(int i=0;i<nums.length;i++){
            new_nums[i]=nums[i]*nums[i];
        }
        boolean flag;
        for(int i=0;i< new_nums.length-1;i++){
            flag=false;
            for(int j=0;j< new_nums.length-1;j++){
                if(new_nums[j]>new_nums[j+1]){
                    int temp=new_nums[j];
                    new_nums[j]=new_nums[j+1];
                    new_nums[j+1]=temp;
                    flag=true;
                }
            }
            if(!flag){
                break;
            }
        }
        return  new_nums;

    }
}


  }

code-双指针

  
package com.shuzijun.leetcode.editor.en;
//因为数组本身有序，平方后，大的值只可能集中在原数组两侧，考虑采用双指针从两边遍历至中间，填充新数组
//
public class SquaresOfASortedArray{
      public static void main(String[] args) {

          Solution solution = new SquaresOfASortedArray().new Solution();
      }
      //leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] new_nums=new int[nums.length];
        int k=nums.length-1;
        int slow_index=0;
        int fast_index=nums.length-1;
        //每次只填充一个元素，使用<=填充最后一个元素，如果取<.会漏一个元素
        for(;slow_index<=fast_index;){
            if(nums[slow_index]*nums[slow_index]<nums[fast_index]*nums[fast_index]){
                new_nums[k--]=nums[fast_index]*nums[fast_index];
                fast_index--;
            }else{
                new_nums[k--]=nums[slow_index]*nums[slow_index];
                slow_index++;
            }
        }


        return new_nums;
    }
}
//leetcode submit region end(Prohibit modification and deletion)

  }

209. 长度最小的子数组

暴力解

  
package com.shuzijun.leetcode.editor.en;
public class MinimumSizeSubarraySum{
      public static void main(String[] args) {
           Solution solution = new MinimumSizeSubarraySum().new Solution();
      }
      //leetcode submit region begin(Prohibit modification and deletion)
class Solution {
          //难点在于确认窗口的边界和窗口如何滑动
          //暴力解法里窗口起始位置从下标0开始增加，每次起始位置变动时都初始化窗口大小为1
          //窗口终点位置取决于窗口大小，并通过target值决定 确定的起始位置下的 最大窗口
          //这里确定的起始位置下，实际会重复判断多次数组，根本原因是每次都初始化窗口大小为1，如 [2,3,1,2,4,3]
          //起始位置为2，判断的窗口依次为 {2}、{2,3}、{2,3,1} 、{2,3,1,2}
          //起始位置为3，判断的窗口为 {3}、{3,1}、{3,1,2}、{3,1,2,4}
          //边界判定：
          //情况1：窗口内1个值就大于等于target
          //情况2: 窗口内若干个连续值大于等于target
          //情况3：窗口内所有值加和都小于target
          //1和2可以用 一个变量sum 共同判定
          //3可以用类似冒泡排序里的flag，通过最终的size值是否变化来判定
    public int minSubArrayLen(int target, int[] nums) {
        //给子数组长度一个最大值
        int size=Integer.MAX_VALUE;
        int sum=0;
        int temp_size=0;
        //本质是通过2层for循环构建一个滑动窗口，第一层是窗口的起始位置，第二层是窗口的终止位置
        //窗口滑动的条件是，窗口值大于target
        //暴力解的窗口大小是让终止位置从起始位置不停向后增加直到大于target
        for (int i = 0; i < nums.length; i++) {
            sum=0;
            for (int j = i; j < nums.length; j++) {
                sum+=nums[j];
                //满足条件时才计算size值
                if(sum>=target){
                    //临时存储窗口长度
                    temp_size=j-i+1;
                    //比较窗口长度和上一次窗口值，并更新最终窗口长度
                    size= size<temp_size ? size:temp_size;
                    //找到满足条件的窗口后，窗口不在增大
                    break;
                }
            }

        }
        if(size==Integer.MAX_VALUE){
            //说明整个数组加起来都没有超过target，窗口最大时仍不满条件
            return 0;
        }else{
            return size;
        }

    }
}
//leetcode submit region end(Prohibit modification and deletion)

  }

动态窗口，窗口大小不初始化为1

package com.shuzijun.leetcode.editor.en;

public class MinimumSizeSubarraySum {
    public static void main(String[] args) {
        Solution solution = new MinimumSizeSubarraySum().new Solution();
    }

    //leetcode submit region begin(Prohibit modification and deletion)
    class Solution {

        public int minSubArrayLen(int target, int[] nums) {
            /**
             * 如果只用一个for循环来表示 滑动窗口的起始位置，那么如何遍历剩下的终止位置？
             *
             * 此时难免再次陷入 暴力解法的怪圈。
             *
             * 所以 只用一个for循环，那么这个循环的索引，一定是表示 滑动窗口的终止位置。
             */
            int size = Integer.MAX_VALUE;
            int sum = 0;
            int temp_size = 0;
            //窗口起始位置
            int left = 0;
            //窗口终止位置
            for (int right = 0; right < nums.length; right++) {
                sum += nums[right];
                while (sum >= target) {
                    temp_size = right - left + 1;
                    size = size < temp_size ? size : temp_size;
                    //动态调整窗口起始位置
                    sum-=nums[left++];
                }
            }
            return  size ==Integer.MAX_VALUE ? 0 :size;
        }
    }
//leetcode submit region end(Prohibit modification and deletion)

}

54 螺旋矩阵

class Solution {
    public int[][] generateMatrix(int n) {
        //定义圈数
        int loop=0;
        //定义起始位置
        int start=0;
        //计数器
        int count=1;
        //遍历用变量
        int i,j;
        //定义接收数组
        int[][] result =new int [n][n];
        //n=3 遍历1圈 n=4/5 遍历2圈
        //遍历遵循左闭右开
        while(loop++<n/2){
            //正方形上侧边
            for(j=start;j<n-loop;j++){
                result[start][j]=count++;
            }
            //正方形右侧边
            //此时j最大
            for(i=start;i<n-loop;i++){
                result[i][j]=count++;
            }
            //正方形下侧边
            //此时i j都最大
            for(;j>start;j--){
                result[i][j]=count++;
            }
            //正方形左侧边
            for(;i>start;i--){
                result[i][j]=count++;
            }
            start++;
        }
        if(n%2==1){
            result[start][start]=count;
        }

        return result;
    }
}