Day2_Java:Leetcode977有序数组的平方，leetcode209长度最小的子数组，leetcode59螺旋矩阵

每日鸡汤：熟练感会让恐惧变得陌生甚至无趣。
1.有序数组的平方Leetcode977

• 注意题目中提到的是升序有序数组，如果数组中的元素全部都是大于0的，那么只需要平方之后倒序就好，如果说包含负数，那么最大的平方数只会在数组两端取到（也就是要么负的越多，要么整的越多），不会在中间取到，因此可以用双指针的方法解决。
• 这里用于标记最大平方数的index是从后往前取，因此每给新数组赋值一次，其值都需要减去1，而left，right每次赋值之后只会有其中一个值变化。同时需要注意的是，left每次是+1，right每次是+1。
• 新数组赋值这里，需要注意的是，只有在left端的数字比right端大的时候，才需要改变顺序，left<=时，均正常赋值就好。
  ！！！一定一定注意细节，数组长度，数组index,left与right每次变化是加是减(在right-=1;耽误了很久没看出来，一直在报越界！！)

class Solution {
    public int[] sortedSquares(int[] nums) {
        int left=0;
        int right=nums.length-1;
        int[] nums2=new int[nums.length];
        int index=nums.length-1;
        while(left<=right){
            int A=nums[left]*nums[left];
            int B=nums[right]*nums[right];
            if (A>B){
                nums2[index]=A;
                left+=1;//从前向后是增加
                index-=1;
            }
            else{
                nums2[index]=B;
                right-=1;//从后向前是减少
                index-=1;

            }
            //index-=1;  
            //left+=1;
            //right-=1;双下标每次只会变一个 
        }
        return nums2;        
}}

2. 长度最小的子数组Leetcode209

• 最开始的想法，一直想的是固定区间的左边，所以导致整个过程非常复杂，自己想半天也没有想清楚，后面看了解析，发现应该转换思维，固定区间的右边会清晰很多（以下代码为错误代码，不能保证for循环中的right每次都可以变化！！！并且还有一些其他的错误，仅做记录
• 注意好好读题，找的是大于等于target，不是刚好等于target
  记录以下错误代码！！！

//以下为错误代码！！！！！！仅做记录使用
class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left=0;
        int right=0;
        int val=0;//区间中的数字和
        int len=0;
        while(left<nums.length){
            for(int i=0;i<=right;i++){
                val+=nums[i];
                //right+=1;
                if(val==target){
                    len=right-left+1;        
                }
                if(val>target){
                    left+=1;
                    right=left;
                    break;
                }
            }
        
        }
    return len;
    }
}

以下是正确代码解析与注意事项

• 首先，需要注意的是，该问题需要固定的是滑动窗口的右边，因为如果固定左边界其实和传统暴力解法没有什么区别
• 最开始的len取的是一个很大的值，为的是能够判断是否存在这样的子串。
• 当sum>=target的时候，需要用的是一个while循环，因为是一个持续变化的过程。比如举[1,1,1,1,100]target=100,当加到最后一项的时候，满足条件了，如果这里用if，那么左边界只会向右移动一位，而我们想要的是一个持续移动的过程。
• 注意长度是right-left+1而不是right-left

//以下为正确代码
class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left=0;
        int len=Integer.MAX_VALUE;
        int sum=0;
        for(int right=0;right<nums.length;right++){
            sum+=nums[right];
            while(sum>=target){
                len=Math.min(len,right-left+1);
                sum=sum-nums[left];
                left+=1;
            }            
        }
        if(len==Integer.MAX_VALUE){
                return 0;
            }else{
                return len;
            }
    }}
    //最后的return语句可以简写为以下：
    //return result == Integer.MAX_VALUE ? 0 : result;

3.螺旋矩阵Leetcode59
这道题非常的妙（好吧，每一道题都非常的妙）
需要注意的就是需要坚持一个原则！区间的开闭一开始就要确定好（左闭右开）
然后就是不断用循环，一定一定要注意细节

class Solution {
    public int[][] generateMatrix(int n) {
        int startx=0;//行标起始点
        int starty=0;//列标起始点
        int minuend=1;//循环一圈会被减去的数
        int loop=0;//一共循环的圈数
        int i;
        int j;
        int count=1;
        int [][] nums= new int[n][n];
        while(loop<n/2){//一共转了n/2圈
            for(j=startx;j<n-minuend;j++){//注意因为区间为左闭右开，所以最后一个元素不能取到，最终取到的是它前面一个元素
                nums[startx][j]=count;
                count+=1;

            }//上
            for(i=startx;i<n-minuend;i++){
                nums[i][j]=count;
                count+=1;
            }//右
            for(;j>starty;j--){
                nums[i][j]=count;
                count+=1;
            }//下
            for(;i>startx;i--){
                nums[i][j]=count;
                count+=1;
            }
            startx+=1;
            starty+=1;
            minuend+=1;
            loop+=1;
        }
        if(n%2==1){
            nums[starty][starty]=count;//注意一下不是i,j就可以了
        }
        return nums;
      
    }
}

PS:
很喜欢一个人听着音乐慢慢学习各种算法的过程。可能这就是所谓的“心流”?整个人非常的安心。希望自己60天能够坚持下来！

加油！！