代码随想录算法训练营第二天| 977.有序数组的平方、 209.长度最小的子数组、 59.螺旋矩阵II

系列文章目录

---

---

一、977.有序数组的平方

（1）977.有序数组的平方

①暴力解法（for循环+冒泡排序）

    //暴力解法
        for (int i = 0; i < nums.length; i++) {
            nums[i]*=nums[i];
        }
        //冒泡排序
        for (int i = 0; i < nums.length-1; i++) {
            for (int j = 0; j < nums.length-1-i; j++) {
                int temp = 0;
                if(nums[j]>nums[j+1]){
                    temp=nums[j+1];
                    nums[j+1]=nums[j];
                    nums[j]=temp;
                }
            }
        }
        return nums;
    }

②双指针法

class Solution {
    public int[] sortedSquares(int[] nums) {
        //双指针法
        int left = 0;
        int right = nums.length - 1;
        int[] result = new int[nums.length];
        int index = result.length - 1;
        while (left <= right) {
            if (nums[left] * nums[left] <= nums[right] * nums[right]) {
                result[index] = nums[right] * nums[right];
                index--;
                right--;
            } else {
                result[index] = nums[left] * nums[left];
                index--;
                left++;
            }
        }
        return result;
    }
}

其中

if(...){
//①...
}else{
//②...
}

中内容分别可写成如下形式：

//①
result[index--] = nums[right] * nums[right--];

//②
result[index--] = nums[left] * nums[left++];

---

二、209.长度最小的子数组

（1）209.长度最小的子数组

①暴力解法（两个for循环）

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //暴力解法
        int sum = 0; // 子序列的数值之和
        int subLength = 0; // 子序列的长度
        int result = Integer.MAX_VALUE; // 最终的结果
        for (int i = 0; i < nums.length; i++) {/ 设置子序列起点为i
            sum = 0;
            for (int j = i; j < nums.length; j++) {
                sum += nums[j];
                if (sum >= target) {// 一旦发现子序列和超过了s，更新result
                    subLength = j - i + 1;// 取子序列的长度
                    result = subLength < result ? subLength : result;
                    break; // 因为我们是找符合条件最短的子序列，所以一旦符合条件就break
                }
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

②滑动窗口法

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //滑动窗口法
        int left = 0;
        int right = 0;
        int sum = 0;
        int subLength = 0;
        int result = Integer.MAX_VALUE;
        for (right = 0; right < nums.length; right++) {
            sum += nums[right];
            while (sum >= target) {//持续移动过程，只能用while不能用if
                subLength = right - left + 1;
                result = subLength < result ? subLength : result;
                sum-=nums[left];
                left++;
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

内循环while可简化成如下形式：

            while (sum >= target) {
                result = Math.min(result, right - left + 1);
                sum -= nums[left++];
            }

---

三、59.螺旋矩阵II

（1）59.螺旋矩阵II

版本一

class Solution {
    public int[][] generateMatrix(int n) {
        //左闭右开
        int startx = 0;//定义每循环一个圈i的起始位置
        int starty = 0;// 定义每循环一个圈j的起始位置
        int loop = 0;// 控制循环次数
        int[][] res = new int[n][n];//定义一个二维数组
        int i;
        int j;//定义在各个循环中使用的变量
        int count = 1;  // 定义填充数字
        int offset = 1; // 需要控制每一条边遍历的长度，每次循环右边界收缩一位

        while (loop < n / 2) { // 判断边界
            // 模拟上侧从左到右
            for (j = starty; j < n - offset; j++) {
                res[startx][j] = count++;
            }
            // 模拟右侧从上到下
            for (i = startx; i < n - offset; i++) {
                res[i][j] = count++;
            }
            // 模拟下侧从右到左
            for (; j >= offset; j--) {
                res[i][j] = count++;
            }
            // 模拟左侧从下到上
            for (; i >= offset; i--) {
                res[i][j] = count++;
            }
            startx++;
            starty++;
            loop++;
            offset++;
        }
        //如果n是奇数
        if (n % 2 != 0) {
            res[startx][starty] = count;
        }
        return res;
    }
/*        //左闭右开
        int start = 0;
        int loop = 0;//其loop++即为offset
        int[][] result = new int[n][n];
        int i, j;
        int count = 1;

        while (loop++ < n / 2) {//先比较，再自增，自增后即为offset
            // 模拟上侧从左到右
            for (j = start; j < n - loop; j++) {//注意从start开始
                result[start][j] = count++;
            }
            // 模拟右侧从上到下
            for (i = start; i < n - loop; i++) {//注意从start开始
                result[i][j] = count++;
            }
            // 模拟下侧从右到左
            for (; j >= loop; j--) {
                result[i][j] = count++;
            }
            // 模拟左侧从下到上
            for (; i >= loop; i--) {
                result[i][j] = count++;
            }
            start++;
        }
        //如果n是奇数
        if(n%2!=0){
            result[start][start]=count;
        }
        return result;
    }*/
}

版本二（简化版）

class Solution {
    public int[][] generateMatrix(int n) {
        //左闭右开
        int start = 0;
        int loop = 0;//其loop++即为offset
        int[][] result = new int[n][n];
        int i, j;
        int count = 1;

        while (loop++ < n / 2) {//先比较，再自增，自增后即为offset
            // 模拟上侧从左到右
            for (j = start; j < n - loop; j++) {//注意从start开始
                result[start][j] = count++;
            }
            // 模拟右侧从上到下
            for (i = start; i < n - loop; i++) {//注意从start开始
                result[i][j] = count++;
            }
            // 模拟下侧从右到左
            for (; j >= loop; j--) {
                result[i][j] = count++;
            }
            // 模拟左侧从下到上
            for (; i >= loop; i--) {
                result[i][j] = count++;
            }
            start++;
        }
        //如果n是奇数
        if(n%2!=0){
            result[start][start]=count;
        }
        return result;
    }
}

---