数组、双指针|LeetCode27、209、977、59

阅前声明：本人java基础不好，以后写的时候会加上一些java语法需要注意的地方，如果问题还请多多交流指正！

---

数组第二部分主要是针对双指针思想展开的。

双指针思想

设置两个指针，fast指针用来指向新数组的内容，slow用来指向新数组的index。通过对fast指向元素内容判断是否需要，进而移动slow来实现内容的更新。

双指针思想常规题目：

LeetCode 27 题目描述+解答

解题思路：这道题目就是数组的原地删除。设置两个指针，分别用来指向新数组要填充的内容和填充的index。这里注意，返回的是数组的长度，也就是slow指针最后的位置，不是返回的数组。看清楚题目要求。

Java代码：

/**
  * 题目Id：27; 
  * 题目：移除元素，remove-element; 
  * 日期：2023-10-26 20:44:34
*/

//给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。 
//
// 不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。 
//
// 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。 
//
// 说明: 
// 为什么返回数值是整数，但输出的答案是数组呢? 
// 请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。 
//
// 示例 1：  
//输入：nums = [3,2,2,3], val = 3
//输出：2, nums = [2,2]
//解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 
//nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。
//
// 示例 2： 
//输入：nums = [0,1,2,2,3,0,4,2], val = 2
//输出：5, nums = [0,1,4,0,3]
//解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面
//的元素。

class Solution {
    public int removeElement(int[] nums, int val) {
        int fast=0;
        int slow=0;

        while (fast< nums.length){
            if (nums[fast]!=val){
                nums[slow++] = nums[fast];
            }
            fast++;
        }
        return slow;

    }
}
}

双指针思想拓展题目：

LeetCode 209 题目描述+解答

解题思路：返回数组中满足要求的最小区间长度。使用滑动窗口解法，也就是双指针+whlie 循环解决。滑动窗口的解题思路是，设置两个指针，分别代表窗口的最左边left和最右边right。开始时，移动right，直到窗口内元素的值大于等于target。当满足这一条件时，由于题目要求找到长度最短的子数组，那么此时就需要保留这一长度结果，并且开始移动right，判断后面是否还有更小的子集和结果。注意，当移动right的时候，要注意将sum中right的值减掉。这里因为是一个持续向后寻找的过程，所以使用while循环，不用if。

Java代码：

import com.jayway.jsonpath.internal.function.numeric.Min;

/**
  * 题目Id：209; 
  * 题目：长度最小的子数组，minimum-size-subarray-sum; 
  * 日期：2023-10-26 22:26:51
*/

//给定一个含有 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

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

}

att：

1、java语法

min函数：math.min

2、整型最大值：Integer.MAX_VALUE

3、result == Integer.MAX_VALUE ? 0 : result; 

如果result等于Integer.MAX_VALUE，那么表达式返回0。否则，返回result。第一个位置是成立的结果，第二个位置是else的结果。

LeetCode 977 题目描述+解答

解题思路：有负数的有序数组的平方。这道题目有暴力的解法就是将数组中的各个元素求平方，然后再对这个数组做排序。这样时间复杂度就会高。双指针的思想就是，无论正数还是负数，数组最两端的平方值一定存在一个最大值，所以每次只需要找到两端中较大的一个，倒着放入到新数组中即可。

Java代码：

/**
  * 题目Id：977; 
  * 题目：有序数组的平方，squares-of-a-sorted-array; 
  * 日期：2023-10-26 20:55:29
*/

//给你一个按 非递减顺序 排序的整数数组 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]

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

att：

1、这里注意java的语法，声明一个已知长度的数组：int[] resultants = new int[j+1]; 

2、注意内存占用。

LeetCode 59 题目描述+解答

解题思路：螺旋数组，这里就是要注意边界问题，统一处理即可。每次都处理第一个不处理最后一个。理清楚关系即可。这是个正方形，需要设置一个值来控制每次缩减的值。

Java代码：

/**
  * 题目Id：59; 
  * 题目：螺旋矩阵 II，spiral-matrix-ii; 
  * 日期：2023-10-26 22:54:30
*/

//给你一个正整数 n ，生成一个包含 1 到 n² 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。 
//
// 示例 1： 
//输入：n = 3
//输出：[[1,2,3],[8,9,4],[7,6,5]]
// 
// 示例 2： 
//输入：n = 1
//输出：[[1]]

class Solution {
    public int[][] generateMatrix(int n) {
        int start =0,offset=1,count=1,loop =0,i=0,j=0;
        int [][] num = new int[n][n];
        while (loop++ < n/2){
            for (j=start; j <n-offset; j++) {
                num[start][j]=count++;
            }
            for (i= start; i<n-offset ; i++) {
                num[i][j]=count++;
            }
            for (; j>start ; j--) {
                num[i][j]=count++;
            }
            for (; i>start ; i--) {
                num[i][j]=count++;
            }
            start ++;
            offset ++;
        }
        if (n%2 == 1){
            num[start][start]=count++;
        }
        return num;
    }
}
}

att:

 1、java 可以这么写 for (; i>start ; i--)