数组基础算法题
1.二分查找
https://leetcode-cn.com/problems/binary-search/
给定一个 n 个元素有序的(升序)整型数组 nums 和一个目标值 target ,写一个函数搜索 nums 中的 target,如果目标值存在返回下标,否则返回 -1
题解:
class Solution {
public int search(int[] nums, int target) {
int left=0;
int right=nums.length-1; // 定义target在左闭右闭的区间里,[left, right]
while(left<=right){ // 当left==right,区间[left, right]依然有效,所以用 <=
int mid = left + (right-left)/2; //等价于(l+r)/2,可以防止left+right溢出(超出整数范围)
if(nums[mid]==target){
return mid;
}else if(nums[mid]>target){
right=mid-1; // target 在右区间,所以[left, middle - 1]
}else{
left=mid+1; // target 在左区间,所以[middle + 1, right]
}
}
return -1;
}
}
//时间复杂度:O(logN)
//空间复杂度:O(1)
注意点:
我们定义 target 是在一个在左闭右闭的区间里,也就是[left, right] (right=nums.length-1,这个很重要)。
区间的定义这就决定了二分法的代码应该如何写,因为定义target在[left, right]区间,所以有如下两点:
- while (left <= right) 要使用 <= ,因为left == right是有意义的,所以使用 <=
- if (nums[mid] > target) right 要赋值为 mid - 1,因为当前这个nums[mid]一定不是target,那么接下来要查找的左区间结束下标位置就是 middle - 1
2.移除元素
https://leetcode-cn.com/problems/remove-element/
给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于 val 的元素,并返回移除后数组的新长度。
不要使用额外的数组空间,你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
方法一:暴力解法
这个题目暴力的解法就是两层for循环,一个for循环遍历数组元素 ,第二个for循环更新数组。
class Solution {
public int removeElement(int[] nums, int val) {
int size=nums.length;
for(int i=0;i<size;i++){
if(nums[i]==val){ // 发现需要移除的元素,就将数组集体向前移动一位
for(int j=i;j<size-1;j++){
nums[j]=nums[j+1];
}
i--; // 因为下表i以后的数值都向前移动了一位,所以i也向前移动一位
size--; // 此时数组的大小-1
}
}
return size;
}
}
//时间复杂度:O(N^2)
//空间复杂度:O(1)
方法简单暴力,但时间复杂度可以提升,推荐使用方法二。
方法二:双指针法
双指针法(快慢指针法): 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
class Solution {
public int removeElement(int[] nums, int val) {
int slow = 0;
for(int fast=0;fast<nums.length;fast++){
if(nums[fast]!=val){
nums[slow]=nums[fast];
slow++; //移动一次,数组长度+1
}
}
return slow;
}
}
// 时间复杂度:O(n)
// 空间复杂度:O(1)
双指针法(快慢指针法)在数组和链表的操作中是非常常见的,很多考察数组、链表、字符串等操作的面试题,都使用双指针法。
3.有序数组的平方
https://leetcode-cn.com/problems/squares-of-a-sorted-array/
给你一个按 非递减顺序 排序的整数数组 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) {
for(int i=0;i<nums.length;i++){
nums[i]=nums[i]*nums[i];
}
Arrays.sort(nums);
return nums;
}
}
// 时间复杂度:O(n+nlogn)
// 空间复杂度:O(logn) (需要O(logn)的栈空间进行排序)
方法二:双指针法
数组其实是有序的, 只不过负数平方之后可能成为最大数了。
那么数组平方的最大值就在数组的两端,不是最左边就是最右边,不可能是中间。
此时可以考虑双指针法了,i指向起始位置,j指向终止位置。
定义一个新数组result,和A数组一样的大小,让k指向result数组终止位置。
- 如果
A[i] * A[i] < A[j] * A[j]
那么result[k--] = A[j] * A[j];
- 如果
A[i] * A[i] >= A[j] * A[j]
那么result[k--] = A[i] * A[i];
class Solution {
public int[] sortedSquares(int[] nums) {
int k=nums.length-1;
int i=0,j=k;
int[] result=new int[nums.length];
while(k>=0){
if(nums[i]*nums[i]<=nums[j]*nums[j]){
result[k--]=nums[j]*nums[j];
j--;
}else{
result[k--]=nums[i]*nums[i];
i++;
}
}
return result;
}
}
//时间复杂度: O(n)
//空间复杂度:O(1) 除了存储答案的数组以外,我们只需要维护常量空间。
4.长度最小的子数组
https://leetcode-cn.com/problems/minimum-size-subarray-sum/
给定一个含有 n 个正整数的数组和一个正整数 s ,找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组,并返回其长度。如果不存在符合条件的子数组,返回 0。
示例:
输入:s = 7, nums = [2,3,1,2,4,3] 输出:2
解释:子数组 [4,3] 是该条件下的长度最小的子数组。
滑动窗口:
所谓滑动窗口,就是不断的调节子序列的起始位置和终止位置,从而得出我们要想的结果。
class Solution {
public int minSubArrayLen(int target, int[] nums) {
int left = 0;
int sum = 0; // 滑动窗口数值之和
int result = Integer.MAX_VALUE;
for (int right = 0; right < nums.length; right++) {
sum += nums[right];
while(sum>=target){ // 使用while,每次更新起始位置,并不断比较子序列是否符合条件
result=Math.min(result,right-left+1); // 取子序列的长度
sum-=nums[left++]; // 这里体现出滑动窗口的精髓之处,不断变更left(子序列的起始位置)
}
}
// 如果result没有被赋值的话,就返回0,说明没有符合条件的子序列
return result == Integer.MAX_VALUE? 0:result;
}
}
//时间复杂度: O(n)
//空间复杂度:O(1)
5.螺旋矩阵II
本题并不涉及到什么算法,就是模拟过程,但却十分考察对代码的掌控能力。
https://leetcode-cn.com/problems/spiral-matrix-ii/
给定一个正整数 n,生成一个包含 1 到 n2 所有元素,且元素按顺时针顺序螺旋排列的正方形矩阵。
示例:
输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]
模拟边界:
设置上下左右变量:t, b, l, r
,然后一碰到边界,边界减一,然后转向
class Solution {
public int[][] generateMatrix(int n) {
int tar=n*n,num=1;
int l=0,r=n-1,t=0,b=n-1;
int[][] res = new int[n][n];
while(num<=tar){
for(int i=l;i<=r;i++) res[t][i]=num++; //左到右
t++;
for(int i=t;i<=b;i++) res[i][r]=num++; //上到下
r--;
for(int i=r;i>=l;i--) res[b][i]=num++; //左到右
b--;
for(int i=b;i>=t;i--) res[i][l]=num++; //下到上
l++;
}
return res;
}
}
//时间复杂度: O(n^2)
//空间复杂度:O(1)
总结:
在面试中,数组是必考的基础数据结构。
其实数组的题目在思想上一般比较简单的,但是如果想高效,并不容易。
前面一共四道经典数组题目,每一道题目都代表一个类型,一种思想。
- 二分法
- 双指针法
- 滑动窗口
- 模拟行为