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

977.有序数组的平方

题目链接：977. 有序数组的平方

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

🤔解题思路

💻I.暴力破解

利用双层for循环，外层循环遍历数组元素，得到数值对应的平方，内层对该数进行向前插入

class Solution {
    public int[] sortedSquares(int[] nums) {
        for(int i = 0;i < nums.length;i++){    //遍历数组
            nums[i] = nums[i] * nums[i];    //得到数的平方
            if(i == 0){
                continue;
            }
            int temp = 0;
            for(int j = i - 1;j >= 0;j--){    //对该元素进行向前插入
                if(nums[j] > nums[j + 1]){    //如果当前元素小于前一个元素，则进行交换
                    temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }else{    //找到元素该在的位置，则退出循环，不继续向前遍历
                    break;
                }
            }
        }
        return nums;    //最后得到的新数组则有序排列
    }
}

💻II.双指针

创建一个数组用于存储结果，从两头向中间遍历数组，并将较大的值从尾部开始向前添加到结果数组中（因为数组是非递减的，可能存在负数，所以数组平方后，两边大中间小）

class Solution {
    public int[] sortedSquares(int[] nums) {
        int[] result = new int[nums.length];    //定义新数组，用于存储结果
        int k = nums.length - 1;    //数组最后一个元素的下标
        for(int i = 0,j = nums.length - 1;i <= j;){    //选择大的值存储到结果数组中，并更新对应的下标
            if(nums[i] * nums[i] > nums[j] * nums[j]){
                result[k--] = nums[i] * nums[i];
                i++;
            }else{
                result[k--] = nums[j] * nums[j];
                j--;
            }
        }
        return result;
    }
}

209.长度最小的子数组

题目链接：209.长度最小的子数组

题目要求：

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

🤔解题思路

💻I.暴力破解

暴力破解法会超出时间限制

利用双层for循环，外层循环遍历数组，内层循环从当前元素开始向后累加，直到和大于等于目标值时结束内层循环

class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        int result = Integer.MAX_VALUE;    //存储结果，初始化为最大整数
        for (int i = 0; i < nums.length; i++) {    //外层循环遍历数组
            int sum = nums[i];
            if (sum >= s)
                return 1;
            for (int j = i + 1; j < nums.length; j++) {    //内层循环从当前开始遍历
                sum += nums[j];    //从当前元素开始向后累加
                if (sum >= s) {    
                    result = Math.min(min, j - i + 1);    //取较小值
                    break;
                }
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;    //如果result == Integer.MAX_VALUE则说明不存在该子数组，返回0
    }
}

💻II.双指针滑动窗口

利用左右指针

①左指针不动，右指针向后移动累加，直到sum >= target时，得到result值；左指针开始向右移动sum累减，只要满足sum >= targe，result持续更新为较小的值；

②当不满足sum >= targe条件时，重复①的步骤；直到遍历完全部元素

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int result = Integer.MAX_VALUE;    //初始化结果为最大整数
        int left = 0;    //初始化左指针指向第一个元素
        int sum = 0;
        for(int right = 0;right < nums.length;right++){    //右指针从下标为0的位置开始遍历
            sum += nums[right];    
            while(sum >= target){    //当sum大于等于目标值时，从左指针开始减去元素
                int subL = right - left + 1;    //当前符合条件的子数组长度
                result = result < subL ? result : subL;    //结果存储较小值
                sum -= nums[left++];    //减去左指针所在的元素，并向后一定左指针
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;    //如果result == Integer.MAX_VALUE则说明不存在该子数组，返回0
    }
}

59.螺旋矩阵 II

题目链接：59. 螺旋矩阵 II

题目要求：

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

示例 ：

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

🤔解题思路

重难点还是边界值的判断，坚持循环不变量的原则很重要！

for循环的顺序依次填充①②③④条边，offset为第几圈

class Solution {
    public int[][] generateMatrix(int n) {
        int startX = 0;
        int startY = 0;
        int offset = 1;
        int count = 1;
        int k = 0;
        int[][] nums = new int[n][n]; 
        while(k < n / 2){
            int i = startX;
            int j = startY;
            for(;j < n - offset;j++){
                nums[i][j] = count++;
            }
            for(;i < n - offset;i++){
                nums[i][j] = count++;
            }
            for(;j > startY;j--){
                nums[i][j] = count++;
            }
            for(;i > startY;i--){
                nums[i][j] = count++;
            }
            startX++;
            startY++;
            offset++;
            k++;
        }
        if(n % 2 == 1){
            nums[startX][startY] = count;
        }
        return nums;
    }
}