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

一. 继续数组相关算法练习

977.有序数组的平方

暴力解法

首先想到的是暴力解法没想到leetcode能过

• 时间复杂度: O(n+n^2) 可以做 O(n^2) , 下面排序用快排的话就是O(n+nlogn) 显然不能满足题目O(n)
• 空间复杂都：O(n)

class Solution {
    public int[] sortedSquares(int[] nums) {
        //暴力
        //1 平方
        for (int i = 0; i < nums.length; i++) {
            nums[i] = nums[i]*nums[i];
        }
        //2 冒泡排序
        for (int i = 0; i < nums.length; i++) {
            for (int j = i; j < nums.length; j++) {
                int temp = nums[j];
                if (nums[i]>nums[j]){
                    nums[j] = nums[i];
                    nums[i] = temp;
                }
            }
        }
        return nums;
    }
}

双指针解法

• 时间复杂度:O(n)
• 空间复杂度:O(2n)

根据题目升序有符号数组所以大数只能在sou或者尾，可以在使用双指针法首尾对比把大数放在新数组尾端

注意点：

1. 首尾双指针取哪段的数哪段前移比较下一位
2. 两个指针会有相遇的情形所以循环终止条件要考虑等于，即：首<=尾

class Solution {
    public int[] sortedSquares(int[] nums) {
        //双指针
        int k = nums.length;
        int[] result = new int[k--];
        for (int i = 0,j = nums.length-1; i <=j;) { //两个指针汇合时是最小数要判断放在result[0]
            if (nums[i]*nums[i]<nums[j]*nums[j]){
                result[k--] = nums[j]*nums[j];
                j--; //哪个指针大哪个指针移动
            }else {
                result[k--] = nums[i]*nums[i];
                i++;
            }
        }
        return result;
    }
}

209.长度最小的子数组

暴力解法(此方法不能过Leetcode)

• 时间复杂度:O(n^2)
• 空间复杂度:O(1)

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

滑动窗口-双指针

• 时间复杂度: O(n)----最坏的情况快慢指针都走了n次所以时间复杂度几位O(2n)==O(n)
• 空间复杂度: O(1)

滑动窗口的思路:

1. 有两个指针快指针一直往后移动,直到总和大于等于目标值,记录当前子列长度;
2. 此时慢指针后移一位,快指针继续上面的操作直到下次大于等于目标值,比较上次子列长度取最小值;
3. 以此循环到最后子列长度不大于数组长度即为最小子列长度;
4. 注意在移动左指针时要使用while，因为有可能移动多次才能时窗口和小于目标值比如序列：[1，1，1，1，1，6]

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //滑动窗口双指针
        int result = Integer.MAX_VALUE; //将返回值设置为最大值,用于后续判断是否存在子数组
        int sum = 0;
        int j = 0; // 头指针
        int subLength = 0;  //每次到达临界点的窗口长度
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
            while (sum>=target){ //这里要移动多次因为有可能出现i前移多次才有可能小于target
                subLength = i-j+1;
                result = result>subLength?subLength:result; //如果当前子列长度小于前期的子列,就替换
                sum -= nums[j++]; //这里将 前指针右移,且目前总和减去j位的
            }
        }
        return result> nums.length?0:result;
    }
}

59.螺旋矩阵

因为边界条件特别多所以很容易绕进去,应遵循循环不变量原则将矩阵拆解

1. 应用左闭右开的原则,矩阵可以拆解为多个上下左右4条边的正方形套圈组合,拆解图如下;
2. 如果n为奇数的话中心为单个数字n^2

class Solution {
    public int[][] generateMatrix(int n) {
        int loop = 0;  // 控制循环次数
        int[][] res = new int[n][n];
        int start = 0;  // 每次循环的开始点(start, start)
        int count = 1;  // 定义填充数字
        int i, j;

        while (loop++ < n / 2) { // 判断边界后，loop从1开始
            // 模拟上侧从左到右
            for (j = start; j < n - loop; j++) {
                res[start][j] = count++;
            }

            // 模拟右侧从上到下
            for (i = start; i < n - loop; i++) {
                res[i][j] = count++;
            }

            // 模拟下侧从右到左
            for (; j >= loop; j--) {
                res[i][j] = count++;
            }

            // 模拟左侧从下到上
            for (; i >= loop; i--) {
                res[i][j] = count++;
            }
            start++;
        }

        if (n % 2 == 1) {
            res[start][start] = count;
        }

        return res;
    }
}