数组 | 数组篇汇总

本文记录的是刷题过程中的重要概念和笔记。如有侵权，请联系删除。

数组基础知识

使用C++的话，要注意vector 和 array的区别

• vector的底层实现是array，严格来讲vector是容器，不是数组。
• 数组的元素是不能删的，只能覆盖。

四大方法

1. 二分法查找
2. 双指针法
3. 双指针变形—滑动窗口
4. 模拟行为
   

-------------------------------------------------------------

704. 二分查找 *

力扣题目链接(opens new window)

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

示例 1:

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

123

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

123

提示：

• 你可以假设 nums 中的所有元素是不重复的。
• n 将在 [1, 10000]之间。
• nums 的每个元素都将在 [-9999, 9999]之间。

思路

对区间的定义没有想清楚，区间的定义就是不变量。

== 二分法第二种写法[left, right) ==

时间复杂度：O(log n)

注意如下两点：

• while (left < right)，这里使用 < ,因为left == right在区间[left, right)是没有意义的
• [left, mid) 与 [mid+1,right)

代码如下：（详细注释）

// 版本二
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int left = 0;
        **int right = nums.size();** // 定义target在左闭右开的区间里，即：[left, right)
        while (left < right) { // 因为left == right的时候，在[left, right)是无效的空间，所以使用 <
            **int middle = left + ((right - left) >> 1); // 防止溢出，也可以写为int mid=left/2+right/2;**
            if (nums[middle] > target) {
                **right = middle; // target 在左区间，在[left, middle)中**
            } else if (nums[middle] < target) {
                **left = middle + 1; // target 在右区间，在[middle + 1, right)中**
            } else { // nums[middle] == target
                return middle; // 数组中找到目标值，直接返回下标
            }
        }
        // 未找到目标值
        return -1;
    }
};

优先级：

相关题目：69.x 的平方根

方法一：二分查找法

class Solution {
public:
    int mySqrt(int x) {
        int left = 0;
        int right = x;
        ~~// int ans = 0;~~

        while(left < right){
            int mid = left  + (right - left) / 2;
            **long long res = (long long)mid * mid;  
						//2^31-1=4 byte,有符号需要8 byte，至少需要用到long**
            if(res == x){
                return mid;
            } else if(res > x){
                right = mid;
            } else {
                ~~// ans = mid;~~
                left = mid + 1;
            }
        }
				// 最后的left可能越过x的界也可能没有，需要判断
        if((long long)left*left > x) return left - 1;
        else return left;
    }
};

• 时间复杂度：$O(\log n)$
• 空间复杂度：$O(1)$

方法三：牛顿迭代法

-------------------------------------------------------------

27. 移除元素 *

力扣题目链接(opens new window)

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

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

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以**「引用」**方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

暴力解法

== 双指针法 ==

双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

定义快慢指针

• 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
• 慢指针：指向更新 新数组下标的位置

双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法。

方法一：未改变相对位置

// 时间复杂度：O(n)
// 空间复杂度：O(1)
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {
            if (val != nums[fastIndex]) {
                nums[slowIndex++] = nums[fastIndex];
            }
        }
        return slowIndex;
    }
};

方法二：相向双指针方法（复习）

基于元素顺序可以改变的题目描述改变了元素相对位置，确保了移动最少元素

/**
* 相向双指针方法，基于元素顺序可以改变的题目描述改变了元素相对位置，确保了移动最少元素
* 时间复杂度：O(n)
* 空间复杂度：O(1)
*/
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int leftIndex = 0;
        int rightIndex = nums.size() - 1;
        while (leftIndex <= rightIndex) {
            // 找左边等于val的元素
            while (leftIndex <= rightIndex && nums[leftIndex] != val){
                ++leftIndex;
            }
            // 找右边不等于val的元素
            while (leftIndex <= rightIndex && nums[rightIndex] == val) {
                -- rightIndex;
            }
            // 将右边不等于val的元素覆盖左边等于val的元素
            if (leftIndex < rightIndex) {
                nums[leftIndex++] = nums[rightIndex--];
            }
        }
        return leftIndex;   // leftIndex一定指向了最终数组末尾的下一个元素
    }
};

-------------------------------------------------------------

977.有序数组的平方

力扣题目链接(opens new window)

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

思路

双指针法

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int leftptr=0,rightptr=nums.size()-1;
        int index = nums.size()-1;
        vector<int> res(nums.size(),0);
        while(leftptr<rightptr){
            if(abs(nums[leftptr])>abs(nums[rightptr])){//减小运算量，直接比较绝对值
                res[index--]=pow(nums[leftptr++],2);//
            }else{
                res[index--]=pow(nums[rightptr--],2);
            }
        }
        res[0]=pow(nums[leftptr],2);
        return res;
    }
};

• ^ 是按位异或

时间O(n)
空间O(n)

-------------------------------------------------------------

209.长度最小的子数组 *

力扣题目链接(opens new window)

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

示例：

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

暴力算法

== 滑动窗口：双指针的变形 ==

滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。

class Solution
{
public:
    int minSubArrayLen(int target, vector<int> &nums)
    {
        int leftptr = 0, rightptr = 0;
        **int res = INT_MAX; // 最大的int
        int sum = 0;       // 滑动窗口的总和**
        for (rightptr = 0; rightptr < nums.size(); rightptr++)
        {
            sum += nums[rightptr];
            while (sum >= target)
            {
                res = res < rightptr - leftptr + 1 ? res : rightptr - leftptr + 1;
                sum -= nums[leftptr++];
            }
        }
        return res == INT_MAX ? 0 : res;
    }
};

• 时间复杂度：O(n)
• 空间复杂度：O(1)

符合了就记录下长度并比较，然后剪掉开头的数值。向右移动开头位置，继续寻找。

-------------------------------------------------------------

59.螺旋矩阵 *

力扣题目链接(opens new window)

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

示例:

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

思路

主要是需要理清思路。

很多同学刚开始做这种题目的时候，上来就是一波判断猛如虎。

结果运行的时候各种问题，然后开始各种修修补补，最后发现改了这里那里有问题，改了那里这里又跑不起来了。

class Solution
{
public:
    vector<vector<int>> generateMatrix(int n)
    {
        // 分类讨论:只有一个数字的情况。后面发现可以合并。
        // if (n == 1)
        // {
        //     vector<vector<int>> res(1, vector<int>(1, 1));
        //     return res;
        // }

        int circle = n / 2; //需要循环的圈数。
        int countline = n - 1; //每一行的个数
        int index = 1; //当前打印的数字
        int startrow = 0, startclo = 0;//打印位置
        vector<vector<int>> res(n, vector<int>(n, 0)); //存储结果
        for (int i = 0; i < circle; i++)
        {
            for (int j = 0; j < countline; j++)
            {   //从左到右
                res[startrow][startclo++] = index++;
            }
            for (int j = 0; j < countline; j++)
            {   //从上到下
                res[startrow++][startclo] = index++;
            }
            for (int j = 0; j < countline; j++)
            {
                res[startrow][startclo--] = index++;
            }
            for (int j = 0; j < countline; j++)
            {
                res[startrow--][startclo] = index++;
            }
            //跳转到新循环的打印位置
            startrow++;
            startclo++;
            //每行打印数-2
            countline -= 2;
        }
        //最后内核一圈，奇数才有这种i情况
        if (res[startrow][startclo] == 0)
            res[startrow][startclo] = index;
        return res;
    }
};