【LeetCode】2.数组系列

总目录：

LeetCode系列导航目录

 

0.理论基础

0.1.要点

数组是存放在连续内存空间上的相同类型数据的集合。

数组可以方便的通过下标索引的方式获取到下标下对应的数据。

在删除或者增添元素的时候，就难免要移动其他元素的地址，只能覆盖而不能删除。

多维数组的地址也是连续的。

 

1.二分查找

1.1.问题描述

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target  ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。
链接：https://leetcode.cn/problems/binary-search

1.2.要点

二分查找就是二分查找范围，注意边界的索引处理

在计算中值索引时注意防止溢出，固定套路为mid=left+(right-left)/2;

1.3.代码实例

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int start=0,end=nums.size()-1;
        int mid=0;
        while(start<=end){
            mid=start+((end-start)>>1);//防止溢出
            if(nums[mid]==target){
                return mid;
            }
            if(nums[mid]>target){
                end=mid-1;
            }
            if(nums[mid]<target){
                start=mid+1;
            }
        }

        return -1;
    }
};

 

2.移除指定元素

2.1.问题描述

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
链接：https://leetcode.cn/problems/remove-element

2.2.要点

不要开辟额外空间，绝对是使用双指针。有快慢指针和对撞指针2种解法。

快慢指针，可以保证有效数据的顺序不变，但存在较多的内存copy。

对撞指针，有效数据的顺序将发生改变，但只存在尽量少的内存copy。

2.3.代码实例

快慢指针

class Solution {
    public int removeElement(int[] nums, int val) {
        int curIndex = 0;
        int len = nums.length;
        for (int i = 0; i < len; i++) {
            // 如果等于就被删除, 后面的向前合并
            if(nums[i] != val){
                nums[curIndex++] = nums[i];
            }
        }
        return curIndex;
    }
}

对撞指针

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int left=0,right=nums.size()-1;
        if(right<0){
            return 0;
        }

        //对撞之后不再迭代
        while(left<=right){
            //先找到最后一个非目标数的值
            if(nums[right]==val){
                right--;
                continue;
            }

            //如果在前面遇到目标值，则将其交换到后面
            if(nums[left]==val){
                swap(nums[left],nums[right]);
                right--;
            }

            left++;
        }

        //right值既为最后一个不为val的索引
        return right+1;
    }
};

 

3.有序数组的平方

3.1.问题描述

非递减顺序：相邻元素不是相等就是递增。

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

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

3.2.要点

这是合并两个有序集合的变种

双指针，分别比较两个集合的顶部元素，放入新的集合中，是一种归并排序算法

3.3.代码实例

归并排序

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n = nums.size();
        int negative = -1;
        for (int i = 0; i < n; ++i) {
            if (nums[i] < 0) {
                negative = i;
            } else {
                break;
            }
        }

        vector<int> ans;
        int i = negative, j = negative + 1;
        while (i >= 0 || j < n) {
            if (i < 0) {
                ans.push_back(nums[j] * nums[j]);
                ++j;
            }
            else if (j == n) {
                ans.push_back(nums[i] * nums[i]);
                --i;
            }
            else if (nums[i] * nums[i] < nums[j] * nums[j]) {
                ans.push_back(nums[i] * nums[i]);
                --i;
            }
            else {
                ans.push_back(nums[j] * nums[j]);
                ++j;
            }
        }

        return ans;
    }
};

 

4.长度最小的子数组

4.1.问题描述

给定一个含有 n 个正整数的数组和一个正整数 target 。
找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
链接：https://leetcode.cn/problems/minimum-size-subarray-sum

4.2.要点

都是正整数，要连续的最短，只需要返回长度

1.滑动窗口法，左缩右伸

4.3.代码实例

1.滑动窗口法

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int minLen=INT_MAX;
        if(nums.size()<1){
            return 0;
        }

        queue<int> sumQ;
        int curLen=0;
        int curSum=0;
        int curId=0;

        while(curId<nums.size()){
            //加上当前到达的值
            sumQ.push(nums[curId]);
            curSum+=nums[curId];

            //满足条件时持续左缩寻找最短长度
            while(curSum>=target){
                curLen=sumQ.size();
                curSum-=sumQ.front();
                sumQ.pop();

                minLen=min(minLen,curLen);
            }    

            //不够时向右延伸1步
            curId++;
        }

        return minLen==INT_MAX?0:minLen;
    }
};

 

5.螺旋矩阵2

5.1.问题描述

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

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

5.2.要点

顺时针

1.模拟，边界收缩

5.3.代码实例

边界收缩法

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {        
        vector<vector<int>> ret(n,vector<int>(n,0));

        int i=0;
        int curVal=1;        
        int up=0,down=n-1,left=0,right=n-1;
        while(up<=down&&left<=right){
            for(i=left;i<=right;i++){
                ret[up][i]=curVal;
                curVal++;
            }
            up++;

            for(i=up;i<=down;i++){
                ret[i][right]=curVal;
                curVal++;
            }
            right--;

            for(i=right;i>=left;i--){
                ret[down][i]=curVal;
                curVal++;
            }
            down--;

            for(i=down;i>=up;i--){
                ret[i][left]=curVal;
                curVal++;
            }
            left++;
        }

        return ret;
    }
};

 

6.总结

6.1.经典套路

二分法

双指针

滑动窗口，精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。

模拟行为，核心是模拟行为+控制边界。

6.2.Fabulaous Mind

 

 

 

 

 

 

 

 

xxx.问题

xxx.1.问题描述

111

xxx.2.要点

222

xxx.3.代码实例

333