977.有序数组的平方
LeetCode题目要求
给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。
示例 1：
输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]
解题思路
由于给定的数组是有序且非递减(递增)，而元素可能为负数，所以需要再平方后再排序
- 思路1，先平方，再进行排序
class Solution {
public int[] sortedSquares(int[] nums) {
// 有序数组，非递减(递增)，可能存在负数，平方后不一定是有序，因此需要再排序
for (int i = 0; i < nums.length; i++) {
int t = nums[i];
nums[i] = t * t;
}
// 使用 Arrays.sort(int[]) 进行自然顺序排序
Arrays.sort(nums);
return nums;
}
}
- 思路2，双指针
class Solution {
public int[] sortedSquares(int[] nums) {
// 双指针怎么解决呢
// 输入：nums = [-4,-1,0,3,10]
// 输出：[0,1,9,16,100]
// 思路：遍历数组，做平方操作，平方后，如果值比后面的大，就与后面的交换
int left = 0; // 左指针
int right = nums.length - 1; // 右指针
int[] result = new int[nums.length]; // 存储平方排序后的结果
int k = right; // k 与 right 相等，从 k 位置开始放值
while (left <= right) {
//如果左指针平方 小于 右指针平方值，那么将大的值，放到 result k 的位置
if (nums[left] * nums[left] < nums[right] * nums[right]) {
result[k--] = nums[right] * nums[right];
right--;
} else {
result[k--] = nums[left] * nums[left];
left++;
}
}
return result;
}
}
重难点
双指针是个巧妙的解法，而且通过一个循环+指针移动就完成了。需要主要的点是：
- while(left<=right) 这里使用的 <=, 需要和 right 的取值对应。
- 指针移动，通过对比平方值，大的往右放，小的放左边
附：学习资料链接
209.长度最小的子数组
LeetCode题目要求
给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
示例 1：
输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
解题思路
- 双指针，通过两个指针的移动，指针对应的值相加如果与 target 相等，记录两个指针间的长度。
这个解法在 LeetCode 上跑居然超时了， 之前可以正常执行，很神奇
class Solution {
public int minSubArrayLen(int target, int[] nums) {
int i = 0;
int j = 0;
int len = nums.length;
int result = Integer.MAX_VALUE;
/* 分析过程
0 1 2 3 4 5
2, 3, 1, 2, 4, 3
i j 2+3=5 < 7 下一次移动 j
i j 2+3+1=6 < 7 这里移动 j
i j 2+3+1+2=8>7 下一次移动 i
i j 3+1+2=6 < 7 这里移动 i
i j 3+1+2+4=10 > 7 下一次移动 i
i j 1+2+4=7 下一次移动i，与 target 相等，记录 j-i+1 = 4-2+1 = 3
i j 2+4=6 < 7 这里移动 i，下一次移动 j
i j 2+4+3=9 > 7 这里移动 j，下一次移动 i
i j 4+3=7 这里移动 i，与 target 相等, 记录 j-i+1= 5-4+1 = 2, 比前值小，返回
*/
while(i <= j && j < len) {
int sum = calc(nums, i, j);
if (sum >= target) {
int l = j - i + 1;
result = l < result ? l : result;
i++;
} else if (sum < target) {
j++;
}
}
return result == Integer.MAX_VALUE ? 0 : result;
}
private int calc(int[] nums, int i, int j) {
int sum = 0;
for(; i <= j; i++) {
sum += nums[i];
}
return sum;
}
}
- carl 解法，滑动窗口
class Solution {
public int minSubArrayLen(int target, int[] nums) {
int left = 0;
int sum = 0;
int result = Integer.MAX_VALUE;
// 遍历数组，过程中通过 left 与 right 指针形成一个滑动的窗口
for (int right = 0; right < nums.length; right++) {
// right 指针计算 每个滑动过的值的和
sum += nums[right];
// 如果滑动过的所有元素的和 大于等于 target ，那么就找到了
while (sum >= target) {
// 判断上一次的 result(窗口大小) 与当前窗口大小相比，取小的
result = Math.min(result, right - left + 1);
// 重新计算窗口内的和，但此时的操作是 将 left 指针右移，并且 sum 中把 left 指针的值减去，下一次再判断是否大于等于 target。
sum -= nums[left++];
}
}
return result == Integer.MAX_VALUE ? 0 : result;
}
}
重难点
需要理解滑动窗口的思想：与双指针类似，通过两个指针形成一个窗口，然后通过移动左右指针，变换窗口的大小，形成与目标值匹配的大小
附：学习资料链接
59.螺旋矩阵II
LeetCode题目要求
给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
示例：
输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]
解题思路
根据题目，需要输出的是一个 int[n][n] 的二位数组，那么输出时需要模拟成一个顺时针的螺旋，输出方式为 从左到右 --> 从上到下 --> 从右到左 --> 从下到上，如此重复，直到输出为 n/2 圈；
代码实现
class Solution {
public int[][] generateMatrix(int n) {
int[][] result = new int[n][n];
int startX = 0, startY = 0; // 每循环一圈的起始位置
int loop = 0; //控制循环次数
int mid = n / 2; // 矩阵中间位置
int count = 1; // 填充数值
int offset = 1; // 控制每个边遍历的长度，每次循环右边界收缩一位
int i, j;
while (loop++ < n / 2) { // 螺旋次数
i = startX;
j = startY;
// 从左到右 左闭右开
for (j = startY; j < n - offset; j++) {
result[startX][j] = count++;
}
// 从上倒下 上闭下开
for (i = startX; i < n - offset; i++) {
result[i][j] = count++;
}
// 从右到左 右闭左开
for (; j > startY; j--) {
result[i][j] = count++;
}
// 从下到上 下闭上开
for (; i > startX; i--) {
result[i][j] = count++;
}
startX++;
startY++;
offset++;
}
if (n % 2 == 1) {
result[mid][mid] = count;
}
return result;
}
}
重难点
- 确定好边界条件，需要注意的就是输出时，始终保持的是 闭开 原则，从开始到结束的形式为：左闭右开-> 上闭下开-> 右闭左开 -> 下闭上开
- 如果 n 是奇数时，要对中间的点进行补充输出，才是完整的
附：学习资料链接