day1：第一章 数组 Part01

今日任务（2024/05/08）

• 数组理论基础
• 704.二分查找
• 27.移除元素

数组理论基础

题目建议： 了解一下数组基础，以及数组的内存空间地址，数组也没那么简单。

知识点

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

• 增删元素时会移动其他元素的地址（因为数组元素不能删除，只能覆盖）
  

• 区别容器和数组：

  • 二者都是存储一系列元素的数据结构
  • 容器：如 std::vector、std::array、std::list 等。
  • vector底层实现是array

  	数组	容器
  内存分配	静态或由程序员手动管理	内部动态管理
  大小调整	固定大小	按需增减
  操作	基本操作	提供成员函数
  性能	访问速度优	提供额外功能、更加安全
  安全性	可能引起越界访问	提供越界检查和自动内存管理
  初始化	指定大小 或 初始化	可以在声明后动态添加元素

  • C++中如何选择：
    • 需要动态大小和高级功能：容器
    • 对于性能要求极高且大小固定：原始数组

• 在C++中二维数组在地址空间上是连续的（连续成一条线）
  

704.二分查找

题目建议：

• 大家能把 704 掌握就可以，35.搜索插入位置 和 34. 在排序数组中查找元素的第一个和最后一个位置 ，如果有时间就去看一下，没时间可以先不看，二刷的时候在看。
• 先把 704写熟练，要熟悉 根据 左闭右开，左闭右闭 两种区间规则 写出来的二分法。

题目：704. 二分查找 - 力扣（LeetCode）

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

示例 1:

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

示例 2:

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

提示：

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

我的思路 [ 用时: 13 m 57 s ]

思路

• 数组是有序的，可以通过二分查找不断缩小区间长度，直至找到元素 或 区间长度为0（没有找到元素）

• 定义初始左右边界[l, r]（左闭右闭），开始循环，直至找到目标值下标/l > r：

  • 取区间的二分中点mid = l + (r - l)/2（防止r + l超过int范围）
  • 判断中点与目标值的关系
    • 若nums[mid] < target，目标值在区间右半边，更新区间边界[mid + 1, r]
    • 若nums[mid] > target，目标值在区间左半边，更新区间边界[l, mid - 1]
    • 若nums[mid] = target，目标值就是mid，返回

• 没有找到目标值，则返回-1

代码

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l = 0, r = nums.size() - 1;
        int res = -1;
        while (l <= r) {
            // 关键点1：防止溢出
            int mid = l + (r - l) / 2;
            // 关键点2：定义左闭右闭
            if (nums[mid] < target) l = mid + 1;
            else if (nums[mid] > target) r = mid - 1;
            else {
                // 可修改：这里直接返回mid（但是在ACM模式中这样写比较好，便于最后统一cout）
                res = mid;
                break;
            }
        }
        return res;
    }
};

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

Carl思路

代码随想录 (programmercarl.com)

看了Carl思路后，发现有一些忽略的问题：

• 二分法的使用前提（否则下标就不是唯一的）：
  1. 有序数组
  2. 无重复元素
• 循环不变量是什么？
  • KIMI：循环不变量是一个在循环开始前成立，并在每次循环迭代结束时仍然保持成立的条件或属性。
  • 要遵循循环不变量的原则，在这道题中，区间边界就是循环不变量

关键点

1. 计算区间中点时要防止溢出
2. 确定区间边界的原则（左闭右开/左闭右闭）

相关题目

• 35.搜索插入位置

• 34.在排序数组中查找元素的第一个和最后一个位置

• 69.x 的平方根

• 367.有效的完全平方数

27.移除元素

题目建议：

• 暴力的解法，可以锻炼一下我们的代码实现能力，建议先把暴力写法写一遍。
• 双指针法 是本题的精髓，今日需要掌握
• 拓展题目可以先不看。

题目：27. 移除元素 - 力扣（LeetCode）

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

说明:

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

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

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 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]，也会被视作正确答案。

示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,3,0,4]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

提示：

• 0 <= nums.length <= 100
• 0 <= nums[i] <= 50
• 0 <= val <= 100

我的思路

题目有2个要求：

• 在原数组中移除指定元素
• 返回处理后的数组的长度

如果不需要在原数组中移除：

• 可以直接遍历所有元素
• 数出非指定元素的个数cnt
• cnt即为满足要求的数组长度

但是这个题目要对原数组进行修改，因此要再想办法

暴力解法 [ 用时: 15 m 36 s ]

后经询问KIMI，这个解法也属于双指针法，并不暴力

思路

• 定义有效数组的最后一个下标为len，初始化len = nums.size() - 1
• 从左至右遍历有效数组（注意，有效数组的下标范围是0~len，是随len的变化而变化的）
  • 遇到非指定元素，cur++
  • 遇到指定元素nums[cur]
    • 交换该元素和有效数组最后一个元素swap(nums[cur], nums[len])
    • 有效数组长度减一，len--

代码

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int cur = 0, len = nums.size() - 1;
        while (cur <= len) {
            if (nums[cur] == val) {
                swap(nums[cur], nums[len]);
                // 注意：因为交换了最后一个元素到cur的位置上，但是这个元素并未检验，因此cur不能增加
                len--;
            } else cur++;
        }
        // 注意：返回值是有效数组的长度，因此是：最大下标 + 1
        return len + 1;
    }
};

• 时间复杂度：$O(n)$

说不上来，这个复杂度是$O(n)$吗？我感觉比$O(n)$小

询问KIMI：时间复杂度是 $O(n)$

• 空间复杂度：$O(1)$

评价

• 我感觉这个方法比去年11月份第一次碰到这个题目时想出来的暴力解法要好很多，嘿嘿。
• 说实话我感觉很惊喜，不知道这算不算一种进步。
• 并且看到这个题目第一种思路是双指针法，然后我鼓励自己先想一想暴力的解法，就想到了这个。
• 看起来代码还是非常简洁的。
• KIMI分析：使用了双指针技术，一个指针 cur 从左向右扫描，另一个指针 len 从右向左扫描

双指针法 [ 用时: 37 m 40 s ]

思路

• 定义两个下标指针：slow = 0，fast = 1
  • slow：在原始数组上从0开始不断生长，成为目标数组。最终的slow即为有效下标的最大值
  • fast：在数组前方探测有效的元素，并提供给slow来生长
• 遍历原始数组，当fast = nums.size()时停止遍历
  • 判断nums[slow]是否是有效元素
    • nums[slow]有效：后移一位，slow++
    • nums[slow]无效：
      • fast往后探测，找到一个有效的nums[fast]
      • 将nums[fast]赋值给nums[slow]（nums[slow]的原始值一点都不重要，可以理解为直接整条覆盖了原始数组）
      • slow和fast均后移一位
• 输出有效长度slow + 1

代码

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slow = 0, fast = 1;
        while (slow < nums.size() && fast < nums.size()) {
            if (nums[slow] == val) {    // nums[slow]无效
                // 关键点1：初始化fast为slow的下一位
                if (fast < slow) fast = slow + 1;
                // 关键点2：找到有效的nums[fast]（这个过程要避免越界）
                while (fast < nums.size() && nums[fast] == val) {
                    fast++;
                }
                // 关键点3：如果fast已经越界了，就不要操作了
                if (fast < nums.size()) {
                    nums[slow++] = nums[fast++];
                }
            } else slow++;
        }
        return slow + 1;
    }
};

分析

按照上述思路，代码运行结果是错误的：

• 用case2看比较明显
• 我们在使用fast往后探测并给nums[slow]赋值的过程中，应该凭空生成slow代表的数组，不需要检测nums[slow]是否有效。
• 一旦检测，就会把fast已探测过的有效值继续保存在数组中，这会导致部分元素被重复保存。
  

修正思路

• 定义两个下标指针：slow = 0，fast = 1
  • slow：在原始数组上从0开始不断生长，成为目标数组***（它只是利用这片地盘而已，效果等同于声明一个新数组后赋值给nums）***。最终的slow即为有效下标的最大值
  • fast：在数组前方探测有效的元素，并提供给slow来生长
• fast往后探测，遍历原始数组：
  • nums[fast]无效：往后探测一个，fast++
  • nums[fast]有效：
    • 将nums[fast]赋值给nums[slow]（nums[slow]的原始值一点都不重要，可以理解为直接整条覆盖了原始数组）
    • slow和fast均后移一位
• 输出有效长度slow + 1

修正代码

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        // 关键点1：初始化时，fast从0开始探测，探测到的有效值将放到slow = 0的位置上
        int slow = 0, fast = 0;
        while (fast < nums.size()) {
            if (nums[fast] == val) fast++;
            else {
                nums[slow++] = nums[fast++];
            }
        }
        // 关键点2：在保存最后一个有效值时，slow仍然++了，因此当前的slow即为有效长度
        return slow;
    }
};

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

两种方法比较

• 性能都是有效且高效的
• 第二种逻辑上可能更直观*（前提是要意识到slow指向的是新数组）*，且避免了元素交换。

Carl思路

代码随想录 (programmercarl.com)

• 双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法
• 要明确一件事：慢指针指向了要更新的新数组下标的位置

相关题目推荐

• 26.删除排序数组中的重复项
• 283.移动零
• 844.比较含退格的字符串
• 977.有序数组的平方

今日收获

• 复习了数组的理论知识：
  • C++中二维数组是连续内存
  • 数组和容器的区别
• 二分查找
  • 注意到二分查找的使用前提：有序、无重复
  • 循环不变量原则
• 双指针法
  • 又叫快慢指针法，我觉得这个名字更有利于我的理解
  • 学习了两种双指针法的实现
• 时间复杂度的理解加深了一点
  • 我总是不是很擅长计算时间复杂度，后面需要找KIMI训练一下

后续工作

• 完成推荐题目的练习
• 找KIMI训练时间复杂度的计算

本文中部分图片源于代码随想录，如有侵权，烦请告知，本人会立马删除。