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

//977.有序数组的平方.给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
public int[] sortedSquares(int[] nums) {
///暴力算法
for (int i = 0; i < nums.length; i++) {
nums[i]=nums[i];
}
//Arrays.sort(nums);
recursionSort(nums, 0, nums.length-1);/
int[] res=new int[nums.length];
int left=0,right=nums.length-1;
int temp=res.length-1;
while(left<=right){
if(nums[left]nums[left]>nums[right]nums[right]){
res[temp--]=nums[left]nums[left++];
}else {
res[temp--]=nums[right]*nums[right--];
}
}
return res;
}
//快速排序算法
private void recursionSort(int[] nums, int left, int right) {
if (left >= right) return; // 当子数组只有一个元素或为空时，无需排序
int temp = nums[left]; // 选择当前子数组的第一个元素作为基准值
int i = left;
int j = right;
while (i < j) {
while (nums[j] >= temp && i < j) { // 从右向左找第一个小于基准值的元素
j--;
}
while (nums[i] <= temp && i < j) { // 从左向右找第一个大于基准值的元素
i++;
}
if (i < j) { // 交换找到的两个元素
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
}
// 将基准值放到中间位置
nums[left] = nums[i];
nums[i] = temp;
// 递归对基准值左边和右边的子数组进行排序
recursionSort(nums, left, i - 1);
recursionSort(nums, i + 1, right);
}

1. 有序数组的平方
   问题描述：给定一个按非递减顺序排序的整数数组nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。
   解决方案：
   使用双指针法，从数组的两端开始，比较平方后的值，将较大的值放入结果数组的末尾，然后移动指针，继续比较，直到所有元素都被处理。
   这种方法的时间复杂度为O(n)，空间复杂度为O(n)。

   //209.长度最小的子数组
   //长度最小的子数组.给定一个含有 n 个正整数的数组和一个正整数 target 。
   //找出该数组中满足其总和大于等于 target 的长度最小的子数组
   // [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
   public static int minSubArrayLen(int target, int[] nums) {
   int sum=0;
   int min=Integer.MAX_VALUE;
   ///暴力算法，在力扣上时间超出限制
   for(int i=0;i<nums.length;i++){
   sum=0;
   for(int j=i;j<nums.length;j++){
   if(sum+nums[j]<target){
   sum=sum+nums[j];
   }else {
   min=Math.min(min,j-i+1);
   break;
   }
   }
   }/
   int left=0;
   for (int right = 0; right < nums.length; right++) { // 右指针遍历数组
   sum += nums[right]; // 将右指针指向的元素加入窗口
   while (sum >= target) { // 当窗口内元素和大于等于target
   min = Math.min(min, right - left + 1); // 更新最小长度
   sum -= nums[left]; // 移除左指针指向的元素
   left++; // 移动左指针
   }
   }

    return min==Integer.MAX_VALUE?0:min;
   

   }

2. 长度最小的子数组
   问题描述：给定一个含有 n 个正整数的数组和一个正整数 target，找出该数组中满足其总和大于等于 target 的长度最小的子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。
   解决方案：
   使用滑动窗口技术，维护一个窗口，窗口内的元素和大于等于 target 时，尝试缩小窗口，更新最小长度。
   这种方法的时间复杂度为O(n)，空间复杂度为O(1)。

   //59.螺旋矩阵II
   public int[][] generateMatrix(int n){
   int[][] res=new int[n][n];
   int count=1;// 矩阵中需要填写的数字
   int startX=0,startY=0;// 每一圈的起始点
   int loop = 1; // 记录当前的圈数
   int i, j; // j 代表列, i 代表行;
   while (loop<=n/2) {
   // 顶部
   // 左闭右开，所以判断循环结束时， j 不能等于 n - loop
   for(j=startY;j<n-loop;j++){
   res[startX][j]=count++;
   }
   // 右列
   // 左闭右开，所以判断循环结束时， i 不能等于 n - loop
   for(i=startX;i<n-loop;i++){
   res[i][j]=count++;
   }
   // 底部
   // 左闭右开，所以判断循环结束时， j != startY
   for (;j>startY;j--){
   res[i][j]=count++;
   }
   // 左列
   // 左闭右开，所以判断循环结束时， i != startX
   for (;i>startX;i--){
   res[i][j]=count++;
   }
   startX+=1;
   startY+=1;
   loop+=1;
   }
   // n 为奇数时，单独处理矩阵中心的值
   if(n%2==1)res[startX][startY]=count;
   return res;
   }

3. 螺旋矩阵II
   问题描述：给定一个正整数 n，生成一个包含 1 到 n² 所有元素，且元素按顺时针螺旋顺序排列的 n x n 正方形矩阵。
   解决方案：
   使用四个指针（startX, startY, loop, count）来控制螺旋填充的起始位置和圈数。
   按照螺旋顺序（右、下、左、上）填充矩阵，每完成一圈，更新起始位置和圈数。
   如果 n 为奇数，单独处理矩阵中心的值。
   这种方法的时间复杂度为O(n²)，空间复杂度为O(n²)。