代码随想录day02

一、有序数组的平方（LeetCode977）

暴力求解

class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] c=new int[nums.length];
        for(int i=0;i<nums.length;i  ){
            c[i]=(int)Math.pow(nums[i],2);      
        }
        // for(int i=0;i<c.length;i  ){
        //     for(int j =i 1;j<c.length;j  ){
        //         if(c[i]>c[j]){
        //             int t = c[i];
        //             c[i]=c[j];
        //             c[j]=t;
        //         }
        //     }
        // }
        Arrays.sort(c);
        return c;
    }
}

采用双指针的思想：平方的最大值肯定在两端取，左右指针从两端逼近比大小，用一个指针指向新数组的最右端并将最大值放入，左右指针依次向中间逼近，新指针依次左移，返回新数组

class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] c=new int[nums.length];
        int k=nums.length-1;
        for(int i=0,j=nums.length-1;i<=j;){
            if((int)Math.pow(nums[i],2)>(int)Math.pow(nums[j],2)){
                c[k--]=(int)Math.pow(nums[i],2);
                i  ;
            }
            else{
                c[k--]=(int)Math.pow(nums[j],2);
                j--;
            }             
        }
        return c;
    }
}

二、螺旋矩阵2（LeetCode59）

通过转圈的方式去填充行列的值，根据n的值判断循环的圈数(n/2)，若为奇数需填充矩阵中间的值，否则按照循环不变量原则从→，↓，←，↑依次填充数值，同时所定义的起始点值 1

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] matrix = new int[n][n];
        int x=0,y=0; //起始点
        int f=0; //循环次数
        int cot=1; //数值
        int i,j;//控制行列数
        while(n/2>f  ){ //判断边界后，f从1开始
            //从左到右
            for(j=x;j<n-f;j  ){
                matrix[x][j]=cot  ;
            }
            //从上到下
            for(i=y;i<n-f;i  ){
                matrix[i][j]=cot  ;
            }
            //从右到左
            for(;j>=f;j--){
                matrix[i][j]=cot  ;
            }
            //从下到上
            for(;i>=f;i--){
                matrix[i][j]=cot  ;
            }
            x  ;
            y  ;
        }
        if(n%2==1){
            matrix[x][y]=cot; //n为奇数给矩阵中间赋值
        }
        return matrix;
    }
}

三、长度最小的子数组（LeetCode209）

暴力求解

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int minlength=Integer.MAX_VALUE;//初始化最大长度
        for(int i=0;i<nums.length;i  ){
            int sum =0; // 枚举一轮后设为0
           for(int j =i;j<nums.length;j  ){
               sum  =nums[j];
               if(sum>=target){
                   minlength =Math.min(minlength,j-i 1);//取最小长度
                   break;
               }
           }
        }
        return minlength==Integer.MAX_VALUE? 0 : minlength; //三目运算取最小值
    }
}

滑动串口：类似于双指针，一个指针作为窗口的起点位置，另一个作为终点，通过移动终点截取符合条件的子序列并求出长度，并且起点逐步后移。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int i=0;
        int minlength=Integer.MAX_VALUE;//初始化最大长度      
        int sum =0; 
        for(int j =0;j<nums.length;j  ){
            sum  =nums[j];
            while(sum>=target){
                minlength =Math.min(minlength,j-i 1);//取最小长度
                sum -= nums[i];
                i  ;
            }
        }
        return minlength==Integer.MAX_VALUE? 0 : minlength; //三目运算取最小值
    }
}

这篇好文章是转载于：学新通技术网