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

LeetCode 977 有序数组的平方

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

文章讲解链接 代码随想录

视频讲解 https://www.bilibili.com/video/BV1QB4y1D7ep

自己的思路：每个数平方之后，用冒泡排序重新排序。

自己的暴力排序代码：

class Solution {
    public int[] sortedSquares(int[] nums) {
        int temp = 0;
        // 可以只用一个变量i，将平方后的数字重新赋值给自己就可以了
        for(int i = 0 ; i < nums.length; i++){
            nums[i]*=nums[i];
        }
        // 冒泡排序
        for(int j=0;j<nums.length-1;j++){
            for(int i = 0;i<nums.length-j-1;i++){
                if(nums[i]>nums[i+1]){
                    temp = nums[i];
                    nums[i]=nums[i+1];
                    nums[i+1]=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[] result = new int[nums.length];
        int k = nums.length-1;
        int i = 0;
        int j = nums.length-1;
        while(i<=j){
            if(nums[i]*nums[i] > nums[j]*nums[j]){
                result[k] = nums[i]*nums[i];
                k--;
                i++;
            }else{
                result[k] = nums[j]*nums[j];
                k--;
                j--;
            }
        }
        return result; 
}
}

 209. 长度最小的子数组

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

文章讲解链接  代码随想录

视频讲解链接 https://www.bilibili.com/video/BV1tZ4y1q7XE

滑动窗口法：

该题注意点：

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

• 窗口内是什么？
• 如何移动窗口的起始位置？
• 如何移动窗口的结束位置？

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

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

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

 

可以发现滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。 

 不要以为for里放一个while就以为是O(n^2)啊， 主要是看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)。

自己写的代码：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        // 不用新建一个数组，可以直接由滑动窗口得到一个子数组
        int sum = 0;
        int i = 0;
        int count = 0;
        int result = nums.length + 1;
        for(int j= 0; j<nums.length;j++){
            sum += nums[j];
            // 当集合的和满足大于target的条件时才开始动起始指针
            while(sum>=target){
                count = j-i+1;
                // 得到此时最小长度的集合后开始动起始指针
                // result = Math.min(result,count);
                result= result < count ? result : count;
                sum-=nums[i];
                // 是先减去nums[i]的值再自增，不然减去的就是nums[i+1]的值了
                i++;
            }
        }
        // 要考虑到不存在符合条件的子数组时，返回0的情况。一直找不到合适的数组时，result就不会发生变化，此时可用三元运算符。
        return result == nums.length + 1 ? 0 : result;
    }
}

题解的代码：

class Solution {

    // 滑动窗口
    public int minSubArrayLen(int s, 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 >= s) {
                result = Math.min(result, right - left + 1);
                sum -= nums[left++];
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

 59.螺旋矩阵II

 题目链接 59 螺旋矩阵II

文章讲解链接 代码随想录

视频讲解链接 https://www.bilibili.com/video/BV1SL4y1N7mV/

题解代码：

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;
    }
}

遇到的困难：209题较难，59题还要再看。

今日学习时长：4小时（1小时复习了昨天的两题）