代码随想录第二天：数组总结-CSDN博客

本文链接：https://blog.csdn.net/qq_44050540/article/details/131731955

数组

数组是存放在连续内存空间上的相同类型数据的集合。
在这里插入图片描述

数组的常见题型

二分查找、移除元素–双指针法、滑动窗口法、找子串、模拟法

二分法查找

https://leetcode.cn/problems/binary-search/

左闭右闭

class Solution {
    public int search(int[] nums, int target) {
        int len = nums.length;
        int left = 0, right= len - 1;
        while( left <= right){
            int mid =  left + (right-left)/2; //这里写错了，需要加上left
            if(nums[mid] > target){
                right = mid - 1;
            }else if ( nums[mid] < target ){
                left = mid + 1;
            }else{
                return mid;
            }
        }
        return -1;
    }
}

左闭右开类似

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

暴力解法时间复杂度：O(n)
二分法时间复杂度：O(logn)
在这道题目中我们讲到了循环不变量原则，只有在循环中坚持对区间的定义，才能清楚的把握循环中的各种细节。

对于二分查找，我们每次操作都将问题的规模缩小为原来的一半。这就意味着，每次操作之后，剩余需要处理的数据量变为原来的1/2。如果我们反过来看，原问题的规模如果增大一倍（即翻倍），那么处理这个新问题所需要的操作数只会增加一个（也就是增加一次二分操作）。
这个原理可以通过对数的性质来理解。对于以2为底的对数来说，log2(2n) = log2(2) + log2(n) = 1 + log2(n)。这就意味着，当问题的规模翻倍时，所需的操作数只增加1，因为log2(2) = 1。这就是为什么说，当我们的数据量翻倍时，二分查找只需要多做一次操作。

移除元素–双指针法

https://leetcode.cn/problems/remove-element/
双指针法（快慢指针法）：通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。
暴力解法时间复杂度：O(n^2)
双指针时间复杂度：O(n)

快慢指针

class Solution {
    public int removeElement(int[] nums, int val) {
    // 快慢指针
    // 一个指针用于创建元素，一个指针用于遍历数组
    int slow = 0 , quick = 0;
    int len = nums.length;
    int result = 0;
    for(quick = 0 ;quick < len; quick ++ ){
        if(nums[quick] != val){
            nums[slow++] = nums[quick];
        }
    }
    return slow;  
    }
}

相向指针

核心思路：这段代码的基本思想是，当遇到等于目标值的元素时，我们将它与数组末尾的元素交换，然后丢弃这个末尾元素。通过这种方式，我们可以保证所有不等于目标值的元素都保存在数组的前端，而等于目标值的元素都被移动到数组的末尾。这种操作的目标是在不需要额外空间的情况下，将所有不等于目标值的元素移动到数组的前部。
为了达到这个目标，我们使用了两个指针，一个从数组的开始向后移（left），另一个从数组的末尾向前移动（right）。left指针的目标是找到等于目标值的元素，而right 指针的目标是找到不等于目标值的元素。当两个指针都找到了目标元素，就将它们交换。
实际上，这个过程可以看作是一种分区操作。在 left 指针左边的元素都不等于目标值，而在 right指针右边的元素都等于目标值。这样，当 left 指针和 right指针相遇时，所有的元素就被分为两部分，左边的元素都不等于目标值，右边的元素都等于目标值。最后返回的 left的值实际上就是不等于目标值的元素的数量。
总的来说，这个方法的核心思想是利用两个指针从数组的两端向中间进行扫描和交换，将等于目标值的元素移动到数组的后部，从而实现在不使用额外空间的情况下移除所有等于目标值的元素。

class Solution {
    public int removeElement(int[] nums, int val) {
    // 相向指针
    int len = nums.length;
    int left = 0, right = len - 1;
    while(right >= 0 && nums[right] == val) right--;
    while(left <= right){
        if(nums[left] == val){//left位置的元素需要移除
            nums[left] = nums[right];
            right --; //将right位置的元素移到left（覆盖），right位置移除
        }
        left ++;
        while(right >= 0 && nums[right] == val) right--;
        }
         return left;
    }
}

滑动窗口法，找子串

https://leetcode.cn/problems/minimum-size-subarray-sum/
https://programmercarl.com/0209.%E9%95%BF%E5%BA%A6%E6%9C%80%E5%B0%8F%E7%9A%84%E5%AD%90%E6%95%B0%E7%BB%84.html

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

滑动窗口的思路：
滑动窗口是一种处理数组/列表的算法，可以把嵌套的循环问题转换成单循环问题，降低时间复杂度。
重要的思路：右边界持续向右扩展，直到总和达到目标值，然后开始尝试收缩左边界，直到无法再收缩（也就是总和小于目标值），再次开始扩展右边界，如此反复，直到右边界到达数组末尾。

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int len = nums.length;
        int left = 0, right = 0;
        int sum = 0;
        int result = Integer.MAX_VALUE;
        for(right = 0; right < len; right ++){
            sum += nums[right];
            while(sum >= target){
                int temp = right - left + 1;
                result = result < temp?result:temp;
                sum -= nums[left++]; // 这里是从左边开始更新，删除左边的元素。
            }
        }
        return result == Integer.MAX_VALUE ? 0 : result;
    }
}

模拟法

59.螺旋矩阵II

https://leetcode.cn/problems/spiral-matrix-ii/59.%E8%9E%BA%E6%97%8B%E7%9F%A9%E9%98%B5II
规范边界

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] result = new int[n][n];
        int start = 0; 
        int loop = 0;
        int count = 1;
        int i,j;
        // 边界左闭右开
        while(loop++ < (n/2)){
            for(j = start ;j  <  n - loop; j ++ ){
                result[start][j] = count ++;
            }
            for(i = start; i < n - loop; i++){
                result[i][j] = count ++;
            }
            for(;j > start ; j--){
                result[i][j] = count ++;
            }
            for(;i > start ; i--){
                result[i][j] = count ++;
            }
            start ++;
        }
        if(n % 2 !=0){
            result[start][start] = count ++;
        }

     return result;
    }
}