算法训练营第二天

第一题：力扣977.有序数组的平方

1.题目

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

我的思路： 平方之后就是一个开口向上的二次函数，最大值一定是在两边，最小值一定是中间。

我的错误分析：在原地进行修改，因为我想的是。两个指针肯定不能同时找到最大值和最小值，left指针找最小值，rigth指针找最大值。但是这是错误的。原地不可能解决这个问题。因为只是解决一边的大小。思维是错误的。
错误的代码

`/ int max = nums.length - 1;
        // int left = 0;
        // int temp;
        // while(max > left){
        //      if(nums[left]*nums[left] > nums[max]*nums[max]){
        //          temp = nums[max];
        //          nums[max] = nums[left]*nums[left];
        //          nums[left] = temp;
        //          max--;
        //      }
        //      else{
        //          nums[max] = nums[max]*nums[max];
        //          max--;

        //      }

        // }
        // nums[left] = nums[left]*nums[left];

        // return nums;`

正确的是需要重新新建一个results数组：

int[] results = new int[nums.length];
        int left = 0;
        int rigth = nums.length  - 1;
        int i = nums.length - 1 ;
        while(left <=rigth){
            if(nums[left] * nums[left] > nums[rigth] * nums[rigth]){
                results[i] = nums[left] * nums[left];
                i--;
                left++;
            }
            else{
                 results[i] = nums[rigth] * nums[rigth];
                 rigth--;
                 i--;
            }


        }
    return results;

继续更新：
第一次记录自己的学习想法，居然还有小伙伴收藏，点赞(不知道是不是机器人)，不过谢谢你们哈哈，也算是我们动力

209.长度最小的子数组：
给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。
首先:
我觉得做题之前先想一下这个题目的特点，这才是最重要的:
1.长度最小的子数组
2.子数字是来连续的 这两个特征很重要。
假设：要求的不是连续得？跨越式得找，这时候双指针有效嘛？应该是无效的，所以，我觉得我们要反过来去想题目为这样设计？
明白了连续得目的，还有就是 长度最小，如果这里是长度最大？？ 这道题肯定就是整个数组
*

但是，如果题目变成这样: 长度最大的数组，满足其和<=s，这时候怎么办？双指针有效吗？ 我初步分析还是不行，如果其他小伙伴有答案可以放在评论区.

所以我明白了最下长度的连续 >=s 的意义。

大家都知道这道题用的是双指针滑动窗口：代码：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0,right;
        int result = Integer.MAX_VALUE;
        int sum = 0;
        for(right = 0;right <= nums.length - 1;right ++ ){
            sum += nums[right];
            while(sum >= target){
                result = Math.min(result, right - left + 1);
                sum = sum - nums[left];
                left ++;
            }
        }
        if(result != Integer.MAX_VALUE){
            return result;
        }
        return 0;
    }
}

同样的题：
给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

这道题主要是三点：
1.循环的圈数：这里肯定是（n/2圈）
2.怎么循环
3.最后的处理，偶数和奇数，最后的结果：偶数不剩，奇数剩一个

我的代码

class Solution {
    public int[][] generateMatrix(int n) {

        int[][] result = new int[n][n];
        //这是重点
        int start_x = 0 ,start_y = 0;
        int offset = 0;
        int count = 1; 
        int i,j;
        int loop = n /2;
        while(loop -- > 0 ){
             for(j = start_y; j  < n - 1 - offset ; j++){
                    result[start_x][j] = count++;
             }
             for(i = start_x; i <n - 1 -offset;i++){
                    result[i][j] = count++;
             }
             for(; j > start_x;j--){
                result[i][j] = count++;
             }
             for(; i > start_y ;i--){
                result[i][j] = count++;
             }

             start_x++;
             start_y++;
             offset++;

        }

        if(n % 2 != 0){
            result[start_x][start_y] = count;
        }

        return result;
    }
}

总结：每次都要反思： 为什么这个题要这样设计为什么要一圈一圈的循环？？
第二：就是为什么属于双指针这一节？

本质上就是双指针的应用。谢谢大家点赞。

上述内容参考过代码随想录