LeetCode ACM模式——数组篇

刷题顺序及思路均来源于代码随想录,网站地址:代码随想录

704. 二分查找

给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target  ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1

示例一:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

提示:

  • 你可以假设 nums 中的所有元素是不重复的。
  • n 将在 [1, 10000]之间。
  • nums 的每个元素都将在 [-9999, 9999]之间。
import java.util.Scanner;

public class BinarySearchTest {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		int n=input.nextInt();
		int[] nums=new int[n];
		for(int i=0;i

35. 搜索插入位置 

给定一个排序数组和一个目标值,在数组中找到目标值,并返回其索引。如果目标值不存在于数组中,返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

实例:

输入: nums = [1,3,5,6], target = 5
输出: 2

 

import java.util.Scanner;

/**
 * @author light
 * @Description  搜索插入位置
 *
 * @create 2023-07-08 21:33
 */
public class SearchCaretPositionTest {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		int n=input.nextInt();
		int[] nums=new int[n];
		for(int i=0;i

27. 移除元素

给你一个数组 nums 和一个值 val,你需要原地 移除所有数值等于 val 的元素,并返回移除后数组的新长度。

不要使用额外的数组空间,你必须仅使用 O(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],也会被视作正确答案。
import java.util.Scanner;

/**
 * @author light
 * @Description 移除元素:
 *
 * 采取快慢指针法:
 * 快指针用于查找新元素数组内容
 * 慢指针用于更新数组下标
 *
 * @create 2023-07-17 20:59
 */
public class RemoveElementTest {
	public static void main(String[] args) {

		Scanner input=new Scanner(System.in);
		int n=input.nextInt();
		int[] nums=new int[n];
		for(int i=0;i

977. 有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums,返回 每个数字的平方 组成的新数组,要求也按 非递减顺序 排序。

实例:

输入:nums = [-4,-1,0,3,10]
输出:[0,1,9,16,100]
解释:平方后,数组变为 [16,1,0,9,100]
排序后,数组变为 [0,1,9,16,100]
import java.util.Arrays;
import java.util.Scanner;

/**
 * @author light
 * @Description 有序数组的平方
 *
 * 采用双指针解法
 * @create 2023-07-21 19:26
 */
public class SortedSquaresTest {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		int n=input.nextInt();
		int[] nums=new int[n];

		for (int i = 0; i < n; i++) {
			nums[i]=input.nextInt();
		}
		int[] res=sortedSquares(nums);
		System.out.println(Arrays.toString(res));

	}

	private static int[] sortedSquares(int[] nums) {
		int left=0;
		int right=nums.length-1;
		int flag=nums.length-1;
		int[] res=new int[nums.length];
		while(left<=right){
			if(nums[left]*nums[left]>nums[right]*nums[right]){
				res[flag--]=nums[left]*nums[left];
				left++;
			} else if (nums[left]*nums[left]<=nums[right]*nums[right]) {
				res[flag--]=nums[right]*nums[right];
				right--;
			}
		}
		return res;
	}
}

209. 长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ,并返回其长度如果不存在符合条件的子数组,返回 0 。

实例:

输入:target = 7, nums = [2,3,1,2,4,3]
输出:2
解释:子数组 [4,3] 是该条件下的长度最小的子数组

import java.util.Scanner;

/**
 * @author light
 * @Description 长度最小的子数组
 * @create 2023-07-21 19:48
 */
public class MinSubArrayLenTest {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		int n=input.nextInt();
		int[] nums=new int[n];
		for (int i = 0; i < n; i++) {
			nums[i]=input.nextInt();
		}
		int target=input.nextInt();
		//暴力解法
		int res1 = minSubArrayLen1(nums, target);
		System.out.println(res1);
		//滑动窗口解法
		int res2 = minSubArrayLen2(nums, target);
		System.out.println(res2);
	}

	private static int minSubArrayLen2(int[] nums,int target) {
		int sum=0;
		int result=Integer.MAX_VALUE;
		int subLength=0;
		for (int i = 0; i < nums.length; i++) {
			sum=0;
			for(int j=i;j=target){
					subLength=j-i+1;
					result=result>subLength?subLength:result;
					break;
				}
			}
		}
		return result==Integer.MAX_VALUE?0:result;
	}

	private static int minSubArrayLen1(int[] nums,int target) {
		int left=0;
		int sum=0;
		int result=Integer.MAX_VALUE;
		for(int right=0;right=target){
				result=Math.min(result,right-left+1);
				sum-=nums[left++];
			}
		}
		return result==Integer.MAX_VALUE?0:result;
	}
}

904. 水果成篮 

你正在探访一家农场,农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示,其中 fruits[i] 是第 i 棵树上的水果 种类 。

你想要尽可能多地收集水果。然而,农场的主人设定了一些严格的规矩,你必须按照要求采摘水果:

  • 你只有 两个 篮子,并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
  • 你可以选择任意一棵树开始采摘,你必须从 每棵 树(包括开始采摘的树)上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次,你将会向右移动到下一棵树,并继续采摘。
  • 一旦你走到某棵树前,但水果不符合篮子的水果类型,那么就必须停止采摘。

给你一个整数数组 fruits ,返回你可以收集的水果的 最大 数目。

实例:

输入:fruits = [1,2,1]
输出:3
解释:可以采摘全部 3 棵树。
import java.util.HashMap;
import java.util.Map;

/**
 * @author light
 * @Description 水果成篮

 * @create 2023-07-22 17:23
 */
public class TotalFruitTest {
	public static void main(String[] args) {
		int[] fruits={3,3,3,1,2,1,1,2,3,3,4};
		int res = totalFruit(fruits);
		System.out.println(res);
	}
	public static int totalFruit(int[] fruits) {
		int n = fruits.length;
		Map cnt = new HashMap();

		int left = 0, ans = 0;
		for (int right = 0; right < n; ++right) {
			cnt.put(fruits[right], cnt.getOrDefault(fruits[right], 0) + 1);
			while (cnt.size() > 2) {
				cnt.put(fruits[left], cnt.get(fruits[left]) - 1);
				if (cnt.get(fruits[left]) == 0) {
					cnt.remove(fruits[left]);
				}
				++left;
			}
			ans = Math.max(ans, right - left + 1);
		}
		return ans;

	}
}

59. 螺旋矩阵 II

给你一个正整数 n ,生成一个包含 1 到 n2 所有元素,且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author light
 * @Description 螺旋矩阵II
 * 给定一个正整数 n,生成一个包含 1 到 n^2 所有元素,且元素按顺时针顺序螺旋排列的正方形矩阵。
 * 示例:
 * 输入: 3
 * 输出: [[ 1, 2, 3 ],
 * 		 [ 8, 9, 4 ],
 *       [ 7, 6, 5 ]]
 * @create 2023-07-23 11:40
 */
public class GenerateMatrixTest {
	public static void main(String[] args) {
		Scanner input=new Scanner(System.in);
		int n=input.nextInt();
		int[][] res = generateMatrix(n);
		for (int i = 0; i < n; i++) {
			System.out.println(Arrays.toString(res[i]));
		}
	}

	public static int[][] generateMatrix(int n) {
		int[][] nums=new int[n][n];
		int loop=0;
		int start=0;
		int offSet=1;
		int i,j;
		int count=1;
		while(loopstart;j--){
				nums[i][j]=count++;
			}
			//从下到上
			for(;i>start;i--){
				nums[i][j]=count++;
			}
			loop++;
			start++;
			offSet++;
		}
		//n为奇数
		if(n%2==1){
			nums[n/2][n/2]=n*n;
		}

		return nums;
	}
}

(PS:以上题目中输入和实例有所差别,除了水果成篮其他题目均多了输入数组长度n的操作)

你可能感兴趣的:(做题总结,leetcode,算法,java)