代码随想录【数组篇】

本篇主要内容如下图大纲所示：

二分查找

力扣题目链接

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

示例1：

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

思路：循环不变量，区间的定义就是不变量。分为两种：左闭右闭和左闭右开

先看左闭右闭代码：因为是左闭右闭，两边都能取得到，所以在判断左右取值时都得取到

public class Solution{
    public int binarySearch(int[] nums, int target){
        int left = 0;
        int right = nums.length - 1;
        while(left <= right){
            int mid = left + (right - left) / 2;
            if(nums[mid] > target) {
                right = mid - 1;
            } else if(nums[mid] < target){
                left = mid + 1;
            } else{
                return mid;
            }
        }
        return -1;
    }
}

再对比左闭右开代码，发现 right 的值都不能加一了，因为取不到，while循环也不能加等号了

public class Solution{
    public int binarySearch(int[] nums, int target){
        int left = 0;
        int right = nums.length;
        while(left < right){
            int mid = left + (right - left) / 2; //直接 (left+right)/2会溢出
            if(nums[mid] > target) {
                right = mid; // 区间 [left,mid)
            } else if(nums[mid] < target){
                left = mid + 1; //区间 [mid + 1, right)
            } else{
                return mid;
            }
        }
        return -1;
    }
}

注意二分法的前提条件：有序且重复元素

接下来分析二分法的时间复杂度：

二分查找的基本思想是:

将 n 个元素分成大致相等的两部分, 取a[n/2] 与 x 做比较, 如果 x = a[n/2], 则找到 x, 算法中止;

如果x < a[n/2], 则只要在数组a的左半部分继续搜索 x, 如果x > a[n/2], 则只要在数组 a 的右半部搜索x.

时间复杂度即是while循环的次数。

总共有n个元素, 渐渐跟下去就是n,n/2,n/4,…n/2^k（接下来操作元素的剩余个数）,其中k就是循环的次数，

由于你 n/2^k 取整后 >= 1 ，即令 n/2^k = 1 ，可得 k = log2n,（是以2为底，n的对数）

所以时间复杂度可以表示O(h)=O(log2n)

移除元素

力扣题目链接

给你一个数组 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。

你不需要考虑数组中超出新长度后面的元素。

思路：注意是原地移除，所以不能用额外的空间。算是一个快慢指针，当该元素不需要移除时，slowIndex才走并把此时的元素存起来

class Solution{
    public 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++;
            }
        }
        return slowIndex;
    }
}

有序数组的平方

力扣题目链接

给你一个按 非递减顺序 排序的整数数组 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]

思路：双指针，已知是非递减的，那么只要比较最左边和最右边谁大，更新result, 相应的左右指针移动一步

这一题和上题相比，快慢指针是同向而行，在某种条件下一个走的更快，双指针是相向而行

class Solution{
    public int[] sortSquares(int[] nums){
        int index = nums.length - 1;
        int left = 0, right = index;
        int[] result = new int[nums.length];
        while(left <= right){
            if(nums[left] * nums[left] > nums[right] * nums[right]){
                result[index--] = nums[left] * nums[left];
                left++;
            } else{
                result[index--] = nums[right] * nums[right];
                right--;
            }
        }
        return result;
    }
}

长度最小的子数组

力扣题目链接

给定一个含有 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

思路：滑动窗口，其实也可以看作是双指针，代码中用while满足题意条件然后不断更新起始位置i从而取到这个区间 [i,j] 满足条件的最小连续子数组

以 nums = [2,3,1,2,4,3] 为例，第一次 走到这[2,3,1,2]满足题意result=4，此时不断变更 i, sum也在变直到不满足条件 [3,1,2]

继续往后走 [3,1,2,4] 满足条件result=4 --> result=3，依此类推直到 [4,3] result=2

代码如下：

class Solution{
    public int minSubArrayLen(int s, int[] nums){
        int i = 0, sum = 0;
        int result = Integer.MAX_VALUE;
        for(int j = 0; j < nums.length; j++){
            sum += nums[j];
            while(sum >= s){ //满足题意之后开始滑动，即更新 sum , i , result 的值
                result = Math.min(result, j - i + 1);
                sum -= nums[i++];
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

再来看时间复杂度，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被操作两次，所以时间复杂度是 2 × n 也就是O(n)。

螺旋矩阵II

力扣题目链接

给定一个正整数 n，生成一个包含 1 到 n^2 所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。

示例:
输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

思路：和二分法那道题一致，保持循环不变量原则，左闭右开，模拟填充二维数组

class Solution{
    public int[][] generateMatrix(int n){
        int[][] result = new int[n][n];//定义返回数组
        int i, j;
        int start = 0; // 定义每次循环的开始点(start, start)
        int loop = 0; //控制循环次数
        int count = 1; // 定义填充数字
        
        while(loop++ < n / 2){ //控制循环次数，loop从1开始，n=3循环1次
            //模拟上侧从左到右
            for(int j = start; j < n - loop; j++){
                result[start][j] = count++;
            }
            //模拟右侧从上到下
            for(int i = start; i < n - loop; i++){
                result[i][j] = count++;
            }
            //模拟下侧从右到左
            for(; j >= loop; j--){
                result[i][j] = count++;
            }
            //模拟右侧从上到下
            for(; i >= loop; i--){
                result[i][j] = count++;
            }
            start++; // 每次循环的开始点(start, start)
        }
        if(n % 2 == 1){
            result[start][start] = count; //count从1开始，如果n为奇数，需要处理中间那个值 先count再++所以这里不需要加1
        }
        return result;
    }
}

时间复杂度 O(n^2): 模拟遍历二维矩阵的时间

空间复杂度 O(1)