代码随想录算法训练营day02|数组 977有序数组平方 209长度最小的子数组

双指针类解题思路：

1、根据题意确定使用双指针类解题

2、for循环里的指针j指向终止位置

3、思考什么时候移动起始位置

4、起始位置移动后，定义的参数如何改变

。。。先就这么多，后续遇到双指针题再补充

977 有序数组的平方

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

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

示例 2：

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

提示：

1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按 非递减顺序 排序

进阶：

请你设计时间复杂度为 O(n) 的算法解决本问题

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/squares-of-a-sorted-array

暴力解法:

遍历,求平方,快速排序

class Solution {
    public int[] sortedSquares(int[] nums) {
        for(int i=0;i<nums.length;i++){
            nums[i]* nums[i]=nums[i];
        }
        Arrays.sort(nums);
        return nums;
    }
}

时间复杂度为 O(nlogn)

双指针解法

思路:平方以后,所有元素的最大值应该在数组两侧,两个指针像中间合拢

输出:由小到大 更新新的数组:下标由大到小

需要:1.一个新的数组

​ 2.新数组指针由大到小更新

​ 3.双指针左右开工,对比 计算

class Solution {
    public int[] sortedSquares(int[] nums) {
          int i=0;
          int j=nums.length-1;
          int index=nums.length-1;
          int[] result=new int[nums.length];
          while(i<=j){
              if(nums[i]*nums[i]>nums[j]*nums[j]){
                  result[index]=nums[i]*nums[i];
                  index--;
                  i++;
              }else{
                  result[index]=nums[j]*nums[j];
                  index--;
                  j--;
              }
          }
        return result;
    }     
}

时间复杂度为 O(n)

209 长度最小的子数组

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

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

示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2：

输入：target = 4, nums = [1,4,4]
输出：1

示例 3：

输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0

提示：

1 <= target <= 109
1 <= nums.length <= 105
1 <= nums[i] <= 105

进阶：

如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/minimum-size-subarray-sum

暴力解法:

两层循环,i指头,j指尾,遍历所有的数组情况,一旦发现和大于target ,更新result ,计算长度

时间复杂度为 O(n^2)

滑动窗口思想(双指针中间的地方)

一个for循环做两个for循环的事情

一个for循环里的指针j指向终止位置,终止位置随循环,一个一个向后移动

如何移动起始位置?

什么时候移动起始位置呢, 当终止位置指向的位置里集合里元素和≥ target,就可以移动起始位置了.

result是最终取的最小长度,当前值和收集的最小值比较,选最小值,持续更新,因此result初始为一个最大值

当起始位置移动了,sum应该把i的起始位置这个值减掉, i++

if和while的选择:

if:判断一次就结束了

while: 持续向后移动

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
          int i=0;
          int sum=0;
          int result=Integer.MAX_VALUE;//长度
          for(int j=0;j<nums.length;j++){
              sum=sum+nums[j];
              while(sum>=target){
                  result=Math.min(result,j-i+1);
                  sum=sum-nums[i];
                  i++;
              }
          }
        return result==Integer.MAX_VALUE?0:result;
    }
}

59 螺旋矩阵

力扣题目链接(https://leetcode.cn/problems/spiral-matrix-ii/)

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

示例:

输入: 3
输出:
[[ 1, 2, 3 ],[ 8, 9, 4 ],[ 7, 6, 5 ]]

思路：

1.边界怎么处理？节点怎么选

前选后不选 左闭右开

2.转几圈？

偶数：n/2 奇数：判断一下模2是不是1，是奇数，填充的数组作为一个单独的赋值，最后遍历的给他就行

3.进入循环

起始位置会变:定义起始位置变量

终止位置:不包含最后一个元素 每一圈终止变量不同 需要一个变量来控制

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] res=new int[n][n];
        int start=0;
        int num=1;
        int j;
        int i;
        int loop=0;

        while(loop++ < n/2){
            
            //模拟上侧左右
            for(j=start;j<n-loop;j++){
                res[start][j]= num++;
            }
            //模拟右侧上下
            for(i=start;i<n-loop;i++){
                res[i][j]=num++;
            }
            //模拟下侧右左
            for(;j>=loop;j--){
                res[i][j]=num++;
            }
            //模拟左侧下上
            for(;i>=loop;i--){
                res[i][j]=num++;
            }
            start++;
        
        }
        if(n%2==1){
            res[start][start]=num;
        }
      return res;
  }
}

1