代码随想录刷题总结与反思 —数组

本文章中仅供自己学习或者向偷懒做笔记的同学提供一个总结！

数组是存放在连续内存空间上的相同类型数据的集合。可以通过下标索引的方式获取到对应的数据，需要注意两点：1. 数组下标是从0开始的；2. 数组内存空间的地址是连续的（二维数组在内存的空间地址也是连续的）。

一、二分查找

方法前提： 数组为有序数组， 数组中无重复元素。

写法：（注意：区间的定义是不变量）

假设问题是：在数组[1, 2, 3, 4, 5, 6, 7, 8, 9]中查找元素3

1、 定义target在一个左闭右闭的区间内： [left, right]

注意两点： 

1. whie(left <= right)，此时要用<=，因为left == right有意义的；

2. if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1

int SearchMid(vector& arr, int target){
    int left = 0;
    int right = arr.size()-1;   
    while(left <= right) 
    {
        int middle = left + (right - left) / 2;
        if (arr[middle] > target){
            right = middle - 1;
        }  
        else if (arr[middle] < target){
            left = middle + 1; 
        }
        else{
            return middle;
        }

    }
    return -1;
}

2、定义target在一个左闭右开的区间内： [left, right)

注意两点： 

1. whie(left < right)，此时要用<，因为left == right是无意义的；

2. if (nums[middle] > target) right 要赋值为 middle ，因为当前这个nums[middle]一定不是target，那么接下来要查找的左区间结束下标位置就是 middle 

int SearchMid(vector& arr, int target){
    int left = 0;
    int right = arr.size()-1;   
    while(left < right) 
    {
        int middle = left + (right - left) / 2;
        if (arr[middle] > target){
            right = middle;
        }  
        else if (arr[middle] < target){
            left = middle + 1; 
        }
        else{
            return middle;
        }

    }
    return -1;
}

二、 移除元素

        数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。

对于需要在同一个数组上操作时，可以考虑使用双指针。双指针的使用方法：

定义一个快指针（遍历数组，通过判断条件给慢指针对应的位置元素进行覆盖），一个慢指针（用来实现更新数组元素以及新数组下标的功能），以实现在一个for循环中完成两个for循环的工作。

例： 给定一个数组nums 和 一个目标值val，原地移除所有数值等于val的元素并返回移除后数组的新长度。

class Solution {
public:
    int removeElement(vector& nums, int val) {
        int slow_point = 0;
        for (int fast_point = 0; fast_point < nums.size();fast_point++)
        {
            if(nums[fast_point] != val){
                nums[slow_point++] = nums[fast_point];
            }
        }
        return slow_point;
    }
};

此时：时间复杂度O(n)，空间复杂度O(1) 。

三、长度最小的子数组

例：给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的 连续 子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

滑动窗口法：

        实现滑动窗口需要确定三点：1、窗口内是什么？2、如何移动窗口的起始位置？3、如何移动窗口的终止位置？滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。对于这道题，窗口内就是满足其和>=7的最小连续子数组；当窗口的值大于7，则移动初始位置；窗口的终止位置就是遍历数组的指针；

class Solution {
public:
    int minSubArrayLen(int s, vector& nums) {
        int result = INT32_MAX;
        int sum = 0; // 滑动窗口数值之和
        int i = 0; // 滑动窗口起始位置
        int subLength = 0; // 滑动窗口的长度
        for (int j = 0; j < nums.size(); j++) {
            sum += nums[j];
            // 注意这里使用while，每次更新 i（起始位置），并不断比较子序列是否符合条件
            while (sum >= s) {
                subLength = (j - i + 1); // 取子序列的长度
                result = result < subLength ? result : subLength;
                sum -= nums[i++]; // 这里体现出滑动窗口的精髓之处，不断变更i（子序列的起始位置）
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

四、螺旋数组

        这种题目主要考察模拟过程，其中要注意的点是要确定上下左右四条边界的位置、要保持循环不变量的原则（循环过程中保持左闭右开/左开右闭）

例题：

力扣54题： 给你一个 m 行 n 列的矩阵 matrix ，请按照顺时针螺旋顺序 ，返回矩阵中的所有元素。

class Solution {
public:
    vector spiralOrder(vector>& matrix) {
        vector vec;
        int row = matrix.size();
        int col = matrix[0].size(); 
        int size = row * col;            
        int left = 0;
        int right = col - 1;
        int top = 0;
        int bottom = row - 1;
        while(size >= 1){                 
            for (int i = left; i <= right && size >= 1; i++){
                vec.push_back(matrix[top][i]);
                size--;
            }
            top++;
            for (int i = top; i <= bottom && size >= 1; i++){
                vec.push_back(matrix[i][right]);
                size--;
            }   
            right--;         
            for (int i = right; i >= left && size >= 1; i--){
                vec.push_back(matrix[bottom][i]);
                size--;
            } 
            bottom--;           
            for (int i = bottom; i >= top && size >= 1; i--){
                vec.push_back(matrix[i][left]);
                size--;
            }
            left++;
        }
        return vec;
    }
};

关于数组的经典考题：

二分法：时间复杂度O(logn)，注意循环不变量原则，即在循环中坚持区间的定义

双指针法：时间复杂度O(n)，通过一个快指针和慢指针在一个for循环下完成两个for循环的工作

滑动窗口：时间复杂度O(n)，重点需要理解滑动窗口如何移动初始位置，达到动态更新窗口大小的

模拟行为：注意循环不变量原则