今日任务(2024/05/08)
- 数组理论基础
- 704.二分查找
- 27.移除元素
数组理论基础
题目建议: 了解一下数组基础,以及数组的内存空间地址,数组也没那么简单。
知识点
-
数组:存放在连续内存空间上的相同类型数据的集合
-
增删元素时会移动其他元素的地址(因为数组元素不能删除,只能覆盖)
-
区别容器和数组:
- 二者都是存储一系列元素的数据结构
- 容器:如
std::vector
、std::array
、std::list
等。 vector
底层实现是array
数组 容器 内存分配 静态或由程序员手动管理 内部动态管理 大小调整 固定大小 按需增减 操作 基本操作 提供成员函数 性能 访问速度优 提供额外功能、更加安全 安全性 可能引起越界访问 提供越界检查和自动内存管理 初始化 指定大小 或 初始化 可以在声明后动态添加元素 - C++中如何选择:
- 需要动态大小和高级功能:容器
- 对于性能要求极高且大小固定:原始数组
-
在C++中二维数组在地址空间上是连续的(连续成一条线)
704.二分查找
题目建议:
- 大家能把 704 掌握就可以,35.搜索插入位置 和 34. 在排序数组中查找元素的第一个和最后一个位置 ,如果有时间就去看一下,没时间可以先不看,二刷的时候在看。
- 先把 704写熟练,要熟悉 根据 左闭右开,左闭右闭 两种区间规则 写出来的二分法。
给定一个
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
提示:
- 你可以假设
nums
中的所有元素是不重复的。n
将在[1, 10000]
之间。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 ( l o g n ) O(logn) O(logn)
- 空间复杂度: O ( 1 ) O(1) O(1)
Carl思路
看了Carl思路后,发现有一些忽略的问题:
- 二分法的使用前提(否则下标就不是唯一的):
- 有序数组
- 无重复元素
- 循环不变量是什么?
- KIMI:循环不变量是一个在循环开始前成立,并在每次循环迭代结束时仍然保持成立的条件或属性。
- 要遵循循环不变量的原则,在这道题中,区间边界就是循环不变量
关键点
- 计算区间中点时要防止溢出
- 确定区间边界的原则(左闭右开/左闭右闭)
相关题目
27.移除元素
题目建议:
- 暴力的解法,可以锻炼一下我们的代码实现能力,建议先把暴力写法写一遍。
- 双指针法 是本题的精髓,今日需要掌握
- 拓展题目可以先不看。
给你一个数组
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)
说不上来,这个复杂度是 O ( n ) O(n) O(n)吗?我感觉比 O ( n ) O(n) O(n)小
询问KIMI:时间复杂度是 O ( n ) O(n) O(n)
- 空间复杂度: O ( 1 ) O(1) 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(n) O(n)
- 空间复杂度: O ( 1 ) O(1) O(1)
两种方法比较
- 性能都是有效且高效的
- 第二种逻辑上可能更直观*(前提是要意识到slow指向的是新数组)*,且避免了元素交换。
Carl思路
- 双指针法(快慢指针法)在数组和链表的操作中是非常常见的,很多考察数组、链表、字符串等操作的面试题,都使用双指针法
- 要明确一件事:慢指针指向了要更新的新数组下标的位置
相关题目推荐
今日收获
- 复习了数组的理论知识:
- C++中二维数组是连续内存
- 数组和容器的区别
- 二分查找
- 注意到二分查找的使用前提:有序、无重复
- 循环不变量原则
- 双指针法
- 又叫快慢指针法,我觉得这个名字更有利于我的理解
- 学习了两种双指针法的实现
- 时间复杂度的理解加深了一点
- 我总是不是很擅长计算时间复杂度,后面需要找KIMI训练一下
后续工作
- 完成推荐题目的练习
- 找KIMI训练时间复杂度的计算
本文中部分图片源于代码随想录,如有侵权,烦请告知,本人会立马删除。