【力扣刷题】（一）数组专题

数组专题

1，数组介绍

数组是一种存储空间为连续型的数据结构。因此，数组在删除元素时较为复杂，查询元素时非常便捷。

而且删除的逻辑本质上是一种覆盖。

2，力扣题型

2.1，704二分查找

题目描述：

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

输入: nums = [-1,0,3,5,9,12], target = 9

输出: 4

解释: 9 出现在 nums 中并且下标为 4

链接：https://leetcode-cn.com/problems/binary-search

适用于有序不重复数组。确定什么时候退出 while 循环。

class Solution {
    
    
    public int search(int[] nums, int target) {
    
         
        int left = 0;
        int right = nums.length -1;
        // 优化,没有的情况下提前结束
        if (target < nums[0] || target > nums[nums.length - 1]) {
    
    
            return -1;
        }
        while(left<=right){
    
    
            // int mid = (right+left)/2;
            // 防止加法溢出，做减法变换
            int mid = left+((right-left)>>1);
            // 第一个判断也会提前结束
            if(nums[mid]==target){
    
    
                return mid;
            }
            else if(nums[mid]<target){
    
    
                left = mid + 1;
            }
            else if(nums[mid]>target){
    
    
                right = mid - 1;
            }
        }
        return -1;
    }
}

2.2，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]，也会被视作正确答案。
链接：https://leetcode-cn.com/problems/remove-element

开始的时候以为直接输出 count 就可以了，但是题目的输出要求是非 val 的数组，但同时只要前 count 位的值为 count 就可以。

class Solution {
    
    
    public int removeElement(int[] nums, int val) {
    
    
        int count = 0; //快指针
        for(int num : nums){
    
     //慢指针
            if(num!=val){
    
    
                nums[count] = num; //用当前值覆盖掉前面的位置
                count++; //count这里也是新一套数组的下标
            }
        }
        return count;
    }
}

最后的新数组应该是【2，2，2，3】。这种方法被称为双指针法，也叫快慢指针法。慢指针是原始for循环索引，而快指针是新数组自己维护的一套索引，它快就在于是自己维护的，不必移动 length 次。

进一步的，可以看到通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

那能不能用在双重for循环的遍历问题中呢？不可以，因为遍历是一个先保持不动，一个动；for可以有条件的迭代自增，简单的自增是没有控制条件的。

2.3，977有序数组的平方

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

示例 ：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]
排序后，数组变为 [0,1,9,16,100]

链接：https://leetcode-cn.com/problems/squares-of-a-sorted-array

法一：先平方，再排序

class Solution {
    
    
    public int[] sortedSquares(int[] nums) {
    
    
        for(int m = 0;m<nums.length;m++){
    
    
            nums[m] = nums[m]*nums[m];
        }
        // 冒泡排序
        for(int i =0;i<nums.length-1;i++){
    
    
            for(int j = 0;j<nums.length-1-i;j++){
    
    
                if(nums[j]>nums[j+1]){
    
    
                    nums[j] = nums[j+1] ^ nums[j];
                    nums[j+1] = nums[j+1] ^ nums[j];
                    nums[j] = nums[j+1] ^ nums[j];
                }
            }
        }
        return nums;
    }
}

法二：使用双指针

class Solution {
    
    
    public int[] sortedSquares(int[] nums) {
    
    
        int size = nums.length;
        int[] arr = new int[size];
        int i=0;
        int j=size-1;
        int k=size-1;
        // 双指针法,一个动，一个不动
        while(i<=j){
    
     //结束条件
            if(nums[i]*nums[i]>nums[j]*nums[j]){
    
    
            arr[k--] =  nums[i]*nums[i];
            i++;
        } else{
    
    
            arr[k--] =  nums[j]*nums[j];
            j--;
            }
        }
        return arr;
    }
}

2.4，209长度最小的子数组

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

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

示例 1：

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

链接：https://leetcode-cn.com/problems/minimum-size-subarray-sum

法一：暴力破解：

class Solution {
    
    
    public int minSubArrayLen(int target, int[] nums) {
    
    
        int sum = 0;
        int subLength = 0;
        int result =  nums.length+1;
        for(int i=0;i<nums.length;i++){
    
    
            sum = 0; //每次需要清零
            for(int j = i;j<nums.length;j++){
    
    
                sum += nums[j];
                if(sum>=target){
    
    
                    subLength = j - i +1;
                    result = result < subLength ? result:subLength; //取最小的sublength
                    break;
                }
            }
        }
        return result==(nums.length+1) ? 0 : result; //返回结果
    }
}

法二：滑动窗口优化

滑动窗口同样是双指针，但区别是双指针间保持固定，当值越界时总是去掉前面一个，从后面新加一个元素过来。时间复杂度从$O(n^2)变为O(n)$。

class Solution {
    
    
    public int minSubArrayLen(int target, int[] nums) {
    
    
        int sum = 0;
        int subLength = 0;
        int result =  nums.length+1;
        int i = 0;
        for(int j = 0;j<nums.length;j++){
    
    
            sum += nums[j];
            while(sum>=target){
    
    
                subLength = j - i +1;
                result = result < subLength ? result:subLength; //取最小的sublength
                sum -= nums[i++]; //滑动窗口，去掉前面一个，从后面一个算起
            }
        }
        return result==(nums.length+1) ? 0 : result; //返回结果
    }
}

2.5，59螺旋矩阵||

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

输入：n = 3
输出：[[1,2,3],[8,9,4],[7,6,5]]

链接：https://leetcode-cn.com/problems/spiral-matrix-ii/

模拟过程：注意分析矩阵形成的方式。

class Solution {
    
    
   public int[][] generateMatrix(int n) {
    
    
        int[][] res = new int[n][n];
        int up = 0, down = n - 1, left = 0, right = n - 1, index = 1;
        while(index <= n * n){
    
    
            for(int i = left; i <= right; i++){
    
    
                // up不动，left指针移位
                res[up][i] = index++;
            }
            //下次left起始移位往下靠了一位
            up++; 
            for(int i = up; i <= down; i++){
    
    
                // right不动，up指针移位
                res[i][right] = index++;
            }
            //下次right起始移位往左靠了一位
            right--; 
            for(int i = right; i >= left; i--){
    
    
                // down不动，right指针移位
                res[down][i] = index++;
            }
            // 下次down起始移位往上靠了一位
            down--;
            for(int i = down; i >= up; i--){
    
    
                // left不动，down指针移位
                res[i][left] = index++;
            }
            // 下次left起始位置往右靠了一位
            left++;
        }
        return res;
    }
}

自己写的一个版本，思路没有上面清晰，供参考：

class Solution {
    
    
    public int[][] generateMatrix(int n) {
    
    
        // 生成一维数组
        int [][]arr = new int[n][n];
        int i,j,m = 0;
        // 根据奇偶判断循环次数
        if(n%2==0){
    
    
            m = n/2;
        }else{
    
    
           m = n/2+1;
        }
        int index = 1;
        /**
        每圈循环动作：
        每个条件判断肯定与i有关
        **/ 
        for( i=0;i<m;i++){
    
    
            // 向左填充，起始j=0，终止n-i；从i开始向左移位
            for( j = i;j<n-i;j++){
    
    
                arr[i][j] = index++;
            }
            // 向下填充，起始j=i+1;终止n-i,从n-i-1开始向下移位（第一个已经填充过了所以-1）
            for( j = i+1;j<n-i;j++){
    
    
                arr[j][n-i-1] = index++;
            }
            // 向右填充，起始j=n-i-1-1(上一轮的列标即是当前的行标，因为方针；因为已填充再减去1)
            for(j=n-i-2;j>=i;j--){
    
    
                arr[n-i-1][j] = index++;
            }
            // 向上填充，起始为上一轮的终止行标；终止j>=i+1（上移每次都会少一位）
            for(j=n-i-2;j>=i+1;j--){
    
    
                arr[j][i] = index++;
            }
        }
        return arr;
    }
}

3，总结

数组是一种连续形存储的数据结构，对于多维数组而言同样如此。同时，数组的元素删除较为复杂，首先找到待删除元素，然后再将后续元素逐个拷贝至前一个位置。

数组相关问题通常涉及到：

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