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

GPKL

已于 2024-03-13 16:59:15 修改

阅读量373

点赞数 8

分类专栏：算法一刷文章标签：算法矩阵数据结构

于 2024-01-11 22:07:37 首次发布

本文链接：https://blog.csdn.net/gpk_tybarmlsh/article/details/135539705

版权

算法一刷专栏收录该内容

2 篇文章 0 订阅

订阅专栏

本文介绍了如何运用双指针法解决LeetCode中的三个问题：有序数组的平方、长度最小的子数组以及生成螺旋矩阵。通过实例展示了如何在编程中实现这些算法，强调了比较、自增操作的顺序对循环逻辑的影响。

摘要由CSDN通过智能技术生成

977.有序数组的平方

双指针法：

视频链接：

双指针法经典题目 | LeetCode：977.有序数组的平方_哔哩哔哩_bilibili

拿下滑动窗口！ | LeetCode 209 长度最小的子数组_哔哩哔哩_bilibili

一入循环深似海 | LeetCode：59.螺旋矩阵II_哔哩哔哩_bilibili

文章链接：

代码随想录 (programmercarl.com)

977.有序数组的平方

题目链接：977. 有序数组的平方 - 力扣（LeetCode）

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

双指针法：

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(k >= 0){
            if(nums[i] * nums[i] <= nums[j] * nums[j]) {
                newNums[k] = nums[j] * nums[j];
                j--;
            }else{
                newNums[k] = nums[i] * nums[i];
                i++;
            }
            k--;
        }
        return newNums;
    }
}

209.长度最小的子数组

public class MinSubArrayLen {
    public static void main(String[] args) {
        int[] nums= {2,3,1,2,4,3};
        int s = 7;
        System.out.println(new MinSubArrayLen().minSubArrayLen(nums, s));
    }

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

59.螺旋矩阵

while (loop++ < n/2){
}

问题：比较、自增、进入循环体的顺序

通过debug能够更直观地看出：

前置自增：先自增，再比较，再进入循环体

后置自增：先比较，再自增，再进入循环体

需要注意的问题：强调循环条件的一致性

import java.util.Arrays;

public class GenerateMatrix {
    public static void main(String[] args) {
        int n = 5;
        System.out.println(Arrays.deepToString(new GenerateMatrix().generateMatrix(n)));

    }

    public int[][] generateMatrix(int n){
        int[][] matrix = new int[n][n];
        int start = 0;
        int count = 1;
        int loop = 0;
        int i, j;
        while (loop++ < n/2){
            for (j = start; j < n - loop; j++) {
                matrix[start][j] = count++;
            }
            for (i = start; i < n - loop; i++) {
                matrix[i][j] = count++;
            }
            for (; j >= loop; j--) {
                matrix[i][j] = count++;
            }
            for (; i >= loop; i--) {
                matrix[i][j] = count++;
            }
            start += 1;
        }

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

        return matrix;
    }
}