LeetCode算法题合集—数组篇

数组基础算法题

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)

总结：

在面试中，数组是必考的基础数据结构。
其实数组的题目在思想上一般比较简单的，但是如果想高效，并不容易。
前面一共四道经典数组题目，每一道题目都代表一个类型，一种思想。

• 二分法
• 双指针法
• 滑动窗口
• 模拟行为