第一章 数组
704. 二分查找法
题目:
给定一个 n
个元素有序的(升序)整型数组 nums
和一个目标值 target
,写一个函数搜索 nums
中的 target
,如果目标值存在返回下标,否则返回 -1
。
示例 1:
输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4
示例 2:
输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1
代码:
// 给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target
// 写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1。
public class ClassSolution704 {
public static void main(String[] args) {
int[] nums = {-1, 0, 3, 5, 9, 12};
int target = 9;
int search = search(nums, target);
System.out.println(search);
}
// 输入: nums = [-1,0,3,5,9,12], target = 9
// 输出: 4
// 解释: 9 出现在 nums 中并且下标为 4
public static int search(int[] nums, int target) {
int left = 0;
int right = nums.length - 1;
while (left <= right) {
int mid = (left + right) / 2;
if (target < nums[mid]) {
right = mid - 1;
} else if (target > nums[mid]) {
left = mid + 1;
} else if (target == nums[mid]) {
return mid;
}
}
return -1;
}
}
思路:
- 定义2个指针,left指针和right指针。
- 当num[mid]==target时,我们就找到了目标值。
- 我们是在重复的计算这个mid值,所以要使用循环。因为不知道要循环多少次,所以使用while循环。
- 循环要有退出条件,当left<=rigth时,我们一直循环,直到找到目标值。
注意:使用循环我们要关注循环的条件以及循环中改变的量。
27. 移除元素
题目:
给你一个数组 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,3,0,4]
解释:函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。
代码:
package com.xiaoyu.w1;
import java.lang.reflect.Array;
import java.util.Arrays;
// 给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于 val 的元素,并返回移除后数组的新长度。
// 不要使用额外的数组空间,你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
// 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
public class ClassSolution27 {
public static void main(String[] args) {
int[] nums = {3, 2, 2, 3};
int val = 3;
int num = removeElement(nums, val);
System.out.println(num);
System.out.println(Arrays.toString(nums));
}
//输入: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],也会被视作正确答案。
public static int removeElement(int[] nums, int val) {
int slowIndex = 0;
for (int fastIndex = 0; fastIndex < nums.length; fastIndex++) {
if (nums[fastIndex] != val) {
nums[slowIndex] = nums[fastIndex];
slowIndex++;
} else if (nums[fastIndex] == val) {
nums[fastIndex] = 0;
}
}
return slowIndex;
}
}
思路:
- 定义两个指针,第一个快指针用来找不是指定值的值,第二个慢指针用来赋值。
- 找到了一个不是指定值的值就通过慢指针赋值,然后慢指针索引+1。
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]
代码:
package com.xiaoyu.array;
import java.util.Arrays;
public class ClassSolution977 {
public static void main(String[] args) {
int[] nums = {-4, -1, 0, 3, 10};
int[] arr = sortedSquares(nums);
System.out.println(Arrays.toString(arr));
}
//给你一个按 非递减顺序 排序的整数数组 `nums`,返回 每个数字的平方 组成的新数组,要求也按 非递减顺序 排序。
//输入:nums = [-4,-1,0,3,10]
//输出:[0,1,9,16,100]
//解释:平方后,数组变为 [16,1,0,9,100]
//排序后,数组变为 [0,1,9,16,100]
public static int[] sortedSquares(int[] nums) {
int[] arr = new int[nums.length];
int left = 0, right = nums.length - 1, index = nums.length - 1;
// 如果是循环条件是left<right,当left==right时,我们就停止循环了
// 但是left和right指向同一个元素时,我们仍然需要将这个元素进行排序
// 因此,循环条件应该是left<=right
while (left <= right) {
if (nums[left] * nums[left] > nums[right] * nums[right]) {
arr[index] = nums[left] * nums[left];
index--;
left++;
} else {
arr[index] = nums[right] * nums[right];
index--;
right--;
}
}
return arr;
}
}
思路:
-
使用三个指针,第一个指针指向左边的第0个元素,第二个指针指向nums.length-1,第三个指针指向新数组的第一个位置。
-
因为数组是从负数开始升序的,让第一个指针指向的值的平方与第二个指针指向的值的平方进行比较,
若第一个大,则将值赋值给第三个指针所指向的位置,并将第一个指针向后移动一个位置,第三个指针向前移动一个位置;
若第二个大,则将值赋值给第三个指针所指向的位置,并将第二个指针向前移动一个位置,第三个指针向前移动一个位置。
209. 长度最小的子数组
题目:
给定一个含有 n
个正整数的数组和一个正整数 target
。
找出该数组中满足其总和大于等于 target
的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr]
,并返回其长度**。**如果不存在符合
条件的子数组,返回 0
。连续子数组:数组的子数组并且是连续的,题目要求找出最小的连续子数组并且和大于target。
示例 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
代码:
package com.xiaoyu.array;
public class ClassSolution209 {
public static void main(String[] args) {
int[] nums = {2, 3, 1, 2, 4, 3};
int len = minSubArrayLen(7, nums);
System.out.println(len);
}
/**
* 给定一个含有 n 个正整数的数组和一个正整数 target 。
* 找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ,并返回其长度。
* 如果不存在符合条件的子数组,返回 0 。
* 示例 1:
* 输入:target = 7, nums = [2,3,1,2,4,3]
* 输出:2
* 解释:子数组 [4,3] 是该条件下的长度最小的子数组。
*/
public static int minSubArrayLen(int target, int[] nums) {
// left指左边界,sum求和,result记录最小数组的长度
int left = 0, sum = 0, len = Integer.MAX_VALUE;
// 遍历数组
for (int right = 0; right < nums.length; right++) {
sum += nums[right];
// 当窗口内元素的和大于等于目标值s时,尝试缩小窗口的左边界
while (sum >= target) {
len = Math.min(len, right - left + 1);
sum -= nums[left];
left++;
}
}
//如果len仍然是初始值,说明没有找到符合条件的子数组,返回0,否则需要返回最小子数组的长度
return len == Integer.MAX_VALUE ? 0 : len;
}
}
思路: 使用两个指针,第一个指针用来遍历数组找到>=target和的一个子数组,第二个指针用来缩小子数组的范围。
59. 螺旋矩阵 II
给你一个正整数 n
,生成一个包含 1
到 n的平方
所有元素,且元素按顺时针顺序螺旋排列的 n x n
正方形矩阵 matrix
。
示例 1:
输入:n = 3
输出:[[1,2,3],[8,9,4],[7,6,5]]
示例 2:
输入:n = 1
输出:[[1]]
代码:
public class ClassSolution59 {
public static void main(String[] args) {
int[][] arr = generateMatrix(3);
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length; j++) {
int num = arr[i][j];
System.out.print(num + "\t");
}
System.out.println();
}
}
/**
* 给你一个正整数 `n` ,生成一个包含 `1` 到 `n的平方` 所有元素,且元素按顺时针顺序螺旋排列的 `n x n` 正方形矩阵 `matrix` 。
* 输入:n = 3
* 输出:
* [
* [1,2,3],
* [8,9,4],
* [7,6,5]
* ]
*/
public static int[][] generateMatrix(int n) {
int loop = 0; // 控制循环次数
int[][] res = new int[n][n];
int start = 0; // 每次循环的开始点
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++;
}
// 模拟下侧从右到左
// ;号前面省略初始化,那么j使用的就是上面循环用完了的j
// j在不满足循环条件后,最后加了一次1
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;
}
}
思路
-
首先要思考,绕圈圈的次数,就是看有多少层。经过观察后发现层数=边长/2,这就是绕圈圈的次数。
-
然后,我们一圈一圈的填充,一条边一条边的遍历填充。
-
这里主要问题,是边界问题,这里我们通过左闭右开填充每条边,填充的位置从0~n-2,也就是填充到倒数第二个位置,最后一个位置由下一条边来填充。
-
填充完一圈后,我们填充下一圈,start起始坐标+1,重复上述步骤。