LeetCode 977.有序数组的平方, 209.长度最小的子数组, 59.螺旋矩阵II

天天向上的勋

于 2023-03-02 13:06:06 发布

阅读量427

点赞数 1

分类专栏：力扣文章标签： java leetcode Powered by 金山文档

本文链接：https://blog.csdn.net/weixin_41809372/article/details/129298647

版权

力扣专栏收录该内容

34 篇文章 0 订阅

订阅专栏

977.有序数组的平方

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

示例 1：

输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]

示例 2：

输入：nums = [-7,-3,2,3,11] 输出：[4,9,9,49,121]

题目链接：https://leetcode.cn/problems/squares-of-a-sorted-array/

暴力解法

思路：先将数组中的所有元素整体平方，然后对平方后的数组进行整体排序

到了Arrays.sort(数组名字) 对数组进行排序

class Solution {
    public int[] sortedSquares(int[] nums) {
        for(int j = 0; j < nums.length; j++){
            nums[j] *= nums[j];
        }
         Arrays.sort(nums);
        return nums;
    }
}

==下面是错误写法，原因大家看下为啥错了==

class Solution {
    public int[] sortedSquares(int[] nums) {
        for(int i = 0; i < nums.length; i++){
            for(int j = i + 1; j < nums.length; j++){
                int a = nums[i];
                int b = nums[j];
                if(a * a > b * b){
                    int temp = a * a;
                    nums[i] = b * b;
                    nums[j] = temp;
                }
            }
        }
        return nums;
    }
}

因为有的数没有平方，有的数又平方了很多次

双指针法

数组其实是有序的，只不过负数平方之后可能成为最大数了。
那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。
此时可以考虑双指针法了，i指向起始位置，j指向终止位置。
定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。
如果A[i] * A[i] < A[j] * A[j] 那么result[k--] = A[j] * A[j]; 。
如果A[i] * A[i] >= A[j] * A[j] 那么result[k--] = A[i] * A[i]; 。
思路：定义两个指针分别指向原数组的头和尾，比较平方后的大小值，大的放新数组中，最后返回新数组

 class Solution {
    public int[] sortedSquares(int[] nums) {
       int i = 0;
       int j = nums.length - 1;
       int k = nums.length - 1;
       int[] newNums = new int[nums.length];
       while(i <= j){//等于号不能省略，因为数组元素个数为奇数时，最后i和j同时指向最后一个元素，还需要把元素放进新数组中呢
           if(nums[i] * nums[i] < nums[j] * nums[j]){
               newNums[k--] = nums[j] * nums[j];
               j--;
           }else{
               newNums[k--] = nums[i] * nums[i];
               i++;
           }
       }
       return newNums;
    }
}

209.长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

输入：s = 7, nums = [2,3,1,2,4,3] 输出：2 解释：子数组 [4,3] 是该条件下的长度最小的子数组。

题目链接：https://leetcode.cn/problems/minimum-size-subarray-sum/

暴力解法

lass Solution {
    public int minSubArrayLen(int target, int[] nums) {
       int minLength = 0;
       int result = Integer.MAX_VALUE;
       for(int i = 0; i < nums.length; i++){
           int sum = 0;
           for(int j = i; j < nums.length; j++){
               sum += nums[j];
               if(sum >= target){
                   minLength = j - i + 1;//因为求区间长度，所以采用此写法
                   result = (result > minLength ? minLength : result);//开始采用最大数与minLength比一定是minLength，之后比较就能得出最小的，此处设计很巧妙
                   break;
               }
           }
       }
       return result == Integer.MAX_VALUE ? 0 : result;//考虑到全加在一起也不够target的情况
    }
}

用到了Integer.MAX_VALUE表示默认为int类型数组的最大值
Math.min(a,b) 工具类比较了两数之间的大小

自己写的

`class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int result = Integer.MAX_VALUE;
        for(int i = 0; i < nums.length; i++){
            int sum = 0;
            int num = 0;
            for(int j = i; j < nums.length; j++){
                sum += nums[j];
                num++;
                if(sum >= target){
                    result = Math.min(result, num);
                    break;
                }
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

上面暴力算法的思想是一样的，不过是写法细节上有差别，具体细节看参数定义以及第二个for循环

==后面力扣更新了数据，暴力解法已经超时了。==

滑动窗口

接下来就开始介绍数组操作中另一个重要的方法：滑动窗口。

所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

很巧妙，多看

在本题中实现滑动窗口，主要确定如下三点：

窗口内是什么？

如何移动窗口的起始位置？

如何移动窗口的结束位置？

窗口就是满足其和 ≥ s 的长度最小的连续子数组。

窗口的起始位置如何移动：如果当前窗口的值大于s了，窗口就要向前移动了（也就是该缩小了）。

窗口的结束位置如何移动：窗口的结束位置就是遍历数组的指针，也就是for循环里的索引。

解题的关键在于窗口的起始位置如何移动，如图所示：

自己理解后写的：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //滑动窗口解法
        int left = 0;
        int sum = 0;
        int result = Integer.MAX_VALUE;
        for(int right = 0; right < nums.length; right++){
            sum += nums[right];
            while(sum >= target){//要想明白这为什么是while，因为left不止移动一次
                result = Math.min(result, right - left + 1);
                sum -= nums[left++];
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

59.螺旋矩阵II

给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

示例:

题目链接：https://leetcode.cn/problems/spiral-matrix-ii/submissions/

class Solution {
    public int[][] generateMatrix(int n) {
        int count = 1;//数组的值
        int i = 0;
        int j = 0;
        int loop = 0;//循环轮数变量
        int offset = 1;//每层循环offset值也在发生改变，所以定义成变量
        int start = 0;
        int mid = n / 2;
        int[][] nums = new int[n][n];
        //因为每一轮循环，i和j最终会落在[0,0]位置，所以需要个start变量来更改位置
        
        while(loop++ < n/2){
            for(j = start; j < n - offset; j++){
                nums[start][j] = count++;
            }
            for(i = start; i < n - offset; i++){
                nums[i][j] = count++;
            }
            for(; j >= offset; j--){
                nums[i][j] = count++;
            }    
            for(;i >= offset; i--){
                nums[i][j] = count++;
            }
            offset++;
            start++;
        }
        if(n % 2 == 1){
            nums[mid][mid] = count;
        }
        return nums;
    }
}