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

977. 有序数组的平方

import java.lang.reflect.Array;
import java.util.Arrays;

public class day2_977_有序数组的平方 {
    public static void main(String[] args) {
        int demo[]={-4,-1,0,3,10};
        System.out.println(Arrays.toString(sortedSquares(demo)));
    }
    public static int[] sortedSquares(int[] nums) {
        //自己的思路：开头一个指针，结尾一个指针，然后新建一个数组，从后往前填充，直到两个正指针碰到(验证正确)
        int len=nums.length;
        int res[]=new int[len];
        int left=0;
        int right=len-1;
        int now=len-1;
        //进入循环
        while (left<=right) {
            if (nums[left] * nums[left] > nums[right] * nums[right]) {
                res[now]=nums[left] * nums[left];
                left+=1;
                
            }else{
                res[now]=nums[right] * nums[right];
                right-=1;
            }
            now-=1;
            
        }
        return res;


    }
    
}

这题主要运用快慢指针的方法，两个指针一个从前一个从后面取元素，然后比较大小然后根据判断结果取移动指针，直到两个指针碰到，训话结束，得到期望结果。

209. 长度最小的子数组

public class day2_209_长度最小的子数组 {
    public static void main(String[] args) {
        int demo[]={5,1,3,5,10,7,4,9,2,8};
        System.out.println(minSubArrayLen(15, demo));
        
    }
    public static int minSubArrayLen(int target, int[] nums) {
        //滑动窗口
        int max=Integer.MAX_VALUE;
        int i=0;
        int sum=0;
        int len=0;
        
        for(int j=0;j<nums.length;j++){
            //依靠快指针进行遍历
            sum+=nums[j];
            while (sum>=target) {
                len=j-i+1;//得到了此时的数组长度
                max=Math.min(max, len);
                //这里是记录当前最小的长度
                //接下来去更新j的位置
                sum=sum-nums[i];
                i+=1;
            }
            
        }
        if (max==Integer.MAX_VALUE) {
            return 0;
            
        }

    
        return max;

    }
}
    

这题的主要思路也是快慢指针，j是快指针，他先去往后面跑，直到遇到符合要求的数组，接着i往后跑，尽量缩小数组的值，然后记录下当前j值的最小数组的长度，然后去遍历每一个j值可能得数组的长度。记录下来最小的结果即可。

59. 螺旋矩阵||

public class day2_59_螺旋矩阵二 {
    public static void main(String[] args) {
        int r=4;
        for(int row=0;row<generateMatrix(r).length;row++){
            for(int col=0;col<generateMatrix(r)[row].length;col++){
                System.out.print(generateMatrix(r)[row][col]+" ");
            }
            System.out.println();
        }
    }
    public static int[][] generateMatrix(int n) {
        //因为是平方，所以一直成立
        int[][] res=new int[n][n];
        //这题主要是模拟过程
        //循环不变量 
        //左闭右开
        // 00 11 22 33这可以看做是每次循环的开始
        //n/2这是上界
        //00 01 02 12 22 21 20  右加 左加 右减 右加的边界是n 左加也是n 右减到 这个n和第几次有关 
        int num=(n)/2;//这是除以2然后向上取证，也就是的到了循环次数
        int a=1;//这个a代表的是第几个数
        int startx=0;
        int starty=0;//这两个是每一圈的起始位置，记得更新，那么末尾的xy就是n-1-lop

        int lop=0;
        while (lop<num) {
            //这个lop代表的是第几圈
            //00 01 .02 12.22 21.11  10
            for(int j=starty;j<n-1-lop;j++){
                res[startx][j]=a;
                a+=1;
            }
            for(int i=startx;i<n-1-lop;i++){
                res[i][n-1-lop]=a;
                a+=1;//这里的巧妙地方在于这个y的取值是n-1-lop也就是上一个循环的终止条件。
            }
            for(int j=n-1-lop;j>lop;j--){
                res[n-1-lop][j]=a;
                a+=1;
            }
            for(int i=n-1-lop;i>lop;i--){
                res[i][lop]=a;
                a+=1;
            }
            startx+=1;
            starty+=1;
            lop+=1;

            
        }
        if (n%2!=0) {
            res[n/2][n/2]=n*n;
            
        }
        return res;

    }
    
}

这题主要不是考察算法，主要是去模拟一个旋转过程，为了方便控制过程，采取了左闭右开的方案，采用其他的也行，合理即可，然后就是去控制边界，有一个点需要注意一下，就是技术偶数的问题，一开始自己想的是向上取证，把技术偶数的情况直接放到循环中去解决，后来发现很麻烦，不如直接在程序末尾直接进行判断，让后把那个数 n的平方填进去方便，主要是就只这个边界条件不好控制。这里的问题