20240322&23&24_ArrayPractise
参考来源:代码随想录,leetcode
704. 二分查找
给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1。
package Practise.ArrayPractice;
public class No_704 {//代码随想录:704.二分查找
//给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target
//写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1。
public static void main(String[] args) {
int[] nums = {1,2,3,4,7,9,10};
System.out.println(search(nums,0));
}
static int search(int[] nums, int target){
if(target < nums[0] || target>nums[nums.length - 1]){
return -1;
}
int left = 0;
int right = nums.length - 1;
while (left <= right){
int mid = left + ((right - left)>>1);
if(nums[mid] == target){
return target;
} else if (nums[mid] < target) {
left = mid + 1;
} else if (nums[mid] > target) {
right = mid - 1;
}
}
return -1;
}
}
27. 移除元素
给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于 val 的元素,并返回移除后数组的新长度。
不要使用额外的数组空间,你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。
示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
你不需要考虑数组中超出新长度后面的元素。
package Practise.ArrayPractice;
public class No_27 {
/*
给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于 val 的元素,并返回移除后数组的新长度。
不要使用额外的数组空间,你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超 出新长度后面的元素。
示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
你不需要考虑数组中超出新长度后面的元素。
*/
public static void main(String[] args) {
int[] nums = {0,1,2,2,3,0,4,2};
int val = 2;
// System.out.println(removeElement1(nums,val));
System.out.println(removeElement(nums,val));
}
public int removeElement1(int[] nums, int val) {//[3,2,2,3],有bug
int size = nums.length;
for (int i = 0; i < nums.length; i++) {
if (nums[i] == val){
for (int j = i + 1; j < nums.length; j++) {
nums[j-1] = nums[j];
}
i--;
size--;
}
}
return size;
}
public static int removeElement(int[] nums, int val) {//快慢指针法
int slowInd = 0;//3,2,2,3
for (int fastInd = 0; fastInd < nums.length;fastInd++){
if (nums[fastInd] != val){
nums[slowInd] = nums[fastInd];
slowInd++;
}
}
return slowInd;
}
}
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 Practise.ArrayPractice;
import java.util.Arrays;
public class No_977 {
/*
给你一个按非递减顺序排序的整数数组 nums,返回 每个数字的平方组成的新数组,要求也按非递减顺序 排序。
输入:nums = [-4,-1,0,3,10]
输出:[0,1,9,16,100]
解释:平方后,数组变为 [16,1,0,9,100],排序后,数组变为 [0,1,9,16,100]
*/
public static void main(String[] args) {
int[] nums = {-4,-1,0,3,100};
System.out.println(Arrays.toString(sortedSquares(nums)));
System.out.println(Arrays.toString(sortedSquares1(nums)));
}
public static int[] sortedSquares1(int[] nums){//暴力法
for (int i = 0; i < nums.length; i++) {
nums[i] = nums[i] * nums[i];
}
for (int j = nums.length - 1; j >=1 ; j--) {
for (int k = nums.length - 2; k >= 0 ; k--) {
if (nums[k + 1] <= nums[k]){
int tmp = nums[k + 1];
nums[k + 1] = nums[k];
nums[k] = tmp;
}
}
}
return nums;
}
public static int[] sortedSquares(int[] nums){//双指针法,一定要非递减才行
int[] res = new int[nums.length];
int l = 0;
int r = nums.length - 1;
int k = nums.length - 1;
while (l<=r){
if(nums[l]*nums[l] > nums[r]*nums[r]){
res[k] = nums[l]*nums[l];
l++;
k--;
}else {
res[k] = nums[r]*nums[r];
r--;
k--;
}
}
return res;
}
}
209.长度最小的子数组
给定一个含有 n 个正整数的数组和一个正整数 s ,找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组,并返回其长度。如果不存在符合条件的子数组,返回 0。
示例:
- 输入:s = 7, nums = [2,3,1,2,4,3]
- 输出:2
- 解释:子数组 [4,3] 是该条件下的长度最小的子数组。
提示:
- 1 <= target <= 10^9
- 1 <= nums.length <= 10^5
- 1 <= nums[i] <= 10^5
package Practise.ArrayPractice;
public class No_209 {
public static void main(String[] args) {
/*
给定一个含有 n 个正整数的数组和一个正整数 s ,找出该数组中满足其和 ≥ s 的长度最小的连续子数组
并返回其长度。如果不存在符合条件的子数组,返回 0。
示例:输入:s = 7, nums = [2,3,1,2,4,3]
输出:2
解释:子数组 [4,3] 是该条件下的长度最小的子数组。
*/
int[] nums = {2,3,1,2,4,3};
System.out.println(minSubArrayLen(7,nums));
}
public static int minSubArrayLen(int target, int[] nums) {//滑动窗口法
int left = 0;
int sum = 0;
int res = Integer.MAX_VALUE;
for (int right = 0; right < nums.length; right++) {
sum += nums[right];
while (sum >= target){
res = Math.min(res,right - left + 1);//判断最小长度
sum -= nums[left++];//精髓
// left++;
}
}
return (res ==Integer.MAX_VALUE ? 0 : res);
}
}
59.螺旋矩阵II
给定一个正整数 n,生成一个包含 1 到 n^2 所有元素,且元素按顺时针顺序螺旋排列的正方形矩阵。
示例:
输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]
package Practise.ArrayPractice;
import java.util.Arrays;
public class No_59 {
/*
给定一个正整数 n,生成一个包含 1到 n^2 所有元素,且元素按顺时针顺序螺旋排列的正方形矩阵。
示例:
输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]
*/
public static void main(String[] args) {
int n = 3;
System.out.println(Arrays.deepToString(generateMatrix(n)));
}
static int[][] generateMatrix(int n) {
int loop = 0; // 控制循环次数
int[][] res = new int[n][n];
int start = 0; // 每次循环的开始点(start, start)
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++;
}
// 模拟下侧从右到左
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;
}
}