参考:
代码随想录
文章目录
1.二分查找
方法:采用 左闭右闭 的区间,
循环结束之后,left 指向最小的(第一个)比 key 大的元素,
right 指向最大的(最后一个)比key小的元素。
代码:
class Solution {
public:
int search(vector<int>& nums, int target) {
int left = 0, right = nums.size() - 1;
while (left <= right) {
int mid = left + ((right - left) / 2);// 防止溢出 等同于(left + right)/2
if (target == nums[mid]) {
return mid;
} else if (target > nums[mid]) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return -1;
}
};
相关题目推荐:
1.1 搜索插入位置
链接:35.搜索插入位置
题目描述:
给定一个排序数组和一个目标值,在数组中找到目标值,并返回其索引。如果目标值不存在于数组中,返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
方法:
在二分查找中,left左边一直比target小,right右边一直比target大,
所以在升序中插入位置是第一个比target大的元素位置,也就是left的位置,
所以直接返回left就可以了。
代码:
class Solution {
public:
int searchInsert(vector<int>& nums, int target) {
int left = 0, right = nums.size() - 1;
while (left <= right) {
int mid = left + (right - left) / 2; // 为了防止越界
if (target == nums[mid]) {
return mid;
} else if (target > nums[mid]) {
left = mid + 1;
} else {
right = mid - 1;
}
}
return left;
}
};
1.2 查找元素的第一个和最后一个位置
题目:
给你一个按照非递减顺序排列的整数数组 nums,和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。
如果数组中不存在目标值 target,返回 [-1, -1]。
你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。
示例 1:
输入:nums = [5,7,7,8,8,10], target = 8
输出:[3,4]
示例 2:
输入:nums = [5,7,7,8,8,10], target = 6
输出:[-1,-1]
方法:
用两个指针来保存第一个与最后一个等于target的元素的位置
这样还是用左闭右闭的区间,还是二分查找的模板,在相等的时候判断一下,其他的就不变。
代码:
class Solution {
public:
vector<int> searchRange(vector<int>& nums, int target) {
int left = 0, right = nums.size() - 1;
// 用两个指针来保存第一个与最后一个等于target的元素的位置
int first = -1, last = -1;
// 找第一个等于target的位置
while (left <= right) {
int middle = (left + right) / 2;
if (nums[middle] == target) {
first = middle; // 记录位置
right = middle - 1; //重点,因为要找第一个等于target的位置,所以要往左边找
} else if (nums[middle] > target) {
right = middle - 1;
} else {
left = middle + 1;
}
}
// 最后一个等于target的位置
left = 0;
right = nums.size() - 1;
while (left <= right) {
int middle = (left + right) / 2;
if (nums[middle] == target) {
last = middle; // 记录位置
left = middle + 1; //重点,因为要找最后一个等于target的位置,所以要往右边找
} else if (nums[middle] > target) {
right = middle - 1;
} else {
left = middle + 1;
}
}
return vector<int>{first, last};
}
};
1.3 求x的平方根
链接:69.x 的平方根
题目:
给你一个非负整数 x ,计算并返回 x 的 算术平方根 。
由于返回类型是整数,结果只保留 整数部分 ,小数部分将被 舍去 。
方法:
用二分查找来做,最后要的结果是向下取整,所以返回 left-1
代码:
class Solution {
public:
int mySqrt(int x) {
if (x == 1) { // 1要特殊处理
return 1;
}
int l = 1, r = x - 1;
while (l <= r) {
int mid = l + (r - l) / 2;
if (x / mid == mid) { // 如果用x > mid*mid,mid*mid可能太大会越界
return mid;
} else if (x / mid > mid) {
l = mid + 1;
} else {
// x/mid < mid
r = mid - 1;
}
}
return l - 1;
}
};
1.4 有效的完全平方数
链接:367.有效的完全平方数
题目:
给你一个正整数 num 。如果 num 是一个完全平方数,则返回 true ,否则返回 false 。
方法:
PS: 和上面求x的平方根差不多,这里会判断一下能否整除。
代码:
class Solution {
public:
bool isPerfectSquare(int num) {
if (num == 1) { // 1要特殊处理
return true;
}
int l = 1, r = num - 1;
while (l <= r) {
int mid = l + (r - l) / 2;
if (num / mid == mid) { // num > mid*mid,mid*mid可能太大会越界
// eg:5/2=2,但是5不是完全平方数
// 所以判断是否可以整除,如果可以整除才是真正的完全平方数
if (num % mid == 0) {
return true;
} else {
return false;
}
} else if (num / mid > mid) {
l = mid + 1;
} else {
// num/mid < mid
r = mid - 1;
}
}
return false;
}
};
2.双指针- 快慢指针的应用
相关题目推荐(使用快慢指针)
2.1 移除元素
链接:27.移除元素
题目:
给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于 val 的元素,并返回移除后数组的新长度。
不要使用额外的数组空间,你必须仅使用 O(1) 额外空间并 原地 修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
方法:
快慢指针法,用两个指针,一个指针表示当前访问位置,一个指针指向实际位置。
代码:
class Solution {
public:
int removeElement(vector<int>& nums, int val) {
// 快慢指针法,用两个指针,一个指针表示当前访问位置,一个指针指向实际位置
int r = 0, i = 0;
while (i < nums.size()) {
if (nums[i] != val) {
nums[r++] = nums[i];
}
i++;
}
return r;
}
};
2.2 删除排序数组中的重复项
链接:26.删除排序数组中的重复项
题目:
给你一个 非严格递增排列 的数组 nums ,请你 原地 删除重复出现的元素,使每个元素 只出现一次 ,返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。
方法:
快慢指针法,用两个指针,一个指针表示当前访问位置,一个指针指向实际位置。
代码:
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
// 双指针法:fast指向当前元素下标,low指向实际被保存的最后一个元素下标
int fast = 1, low = 0;
// 从第二个元素开始判断
while (fast < nums.size()) {
if (nums[fast] != nums[low]) {
nums[++low] = nums[fast];
}
fast++;
}
return low + 1;
}
};
2.3 移动零
链接:283.移动零
题目:
给定一个数组 nums,编写一个函数将所有 0 移动到数组的末尾,同时保持非零元素的相对顺序。
请注意 ,必须在不复制数组的情况下原地对数组进行操作。
我的方法一:
双指针法:fast指向当前元素下标,low指向实际被保存的最后一个元素下标,最后的位置全补上0
代码:
class Solution {
public:
void moveZeroes(vector<int>& nums) {
// 双指针法:fast指向当前元素下标,low指向实际被保存的最后一个元素下标,最后的位置全补上0
int fast = 0, low = 0;
while (fast < nums.size()) {
if (nums[fast] != 0) {
nums[low++] = nums[fast];
}
fast++;
}
while (low < nums.size()) {
nums[low++] = 0;
}
}
};
这里题目中要求不能复制数组,所以按照官方的答案,是 用交换来实现的。
方法二(官方:)
使用双指针,左指针指向当前已经处理好的序列的尾部,右指针指向待处理序列的头部。
右指针不断向右移动,每次右指针指向非零数,则将左右指针对应的数交换,同时左指针右移。
注意到以下性质:
- 左指针左边均为非零数;
- 右指针左边直到左指针处均为零。
因此每次交换,都是将左指针的零与右指针的非零数交换,且非零数的相对顺序并未改变。
class Solution {
public:
void moveZeroes(vector<int>& nums) {
// 方法二:交换元素
int fast = 0, low = 0;
while (fast < nums.size()) {
if (nums[fast] != 0) {
swap(nums[low], nums[fast]);
low++;
}
fast++;
}
}
};
2.4 比较含退格的字符串
链接:844.比较含退格的字符串
题目:
给定 s 和 t 两个字符串,当它们分别被输入到空白的文本编辑器后,如果两者相等,返回 true 。# 代表退格字符。
注意:如果对空文本输入退格字符,文本继续为空。
方法一:双指针
双指针法:fast指向当前元素下标,low指向实际被保存的最后一个元素下标。
(1)对于每一个字符串,都使用双指针来处理,遇到退格,指针low就回退一步,最终结果以low指针为结尾。
(2)两个字符串在一起比较,如果两个长度不一样,直接返回false,否则,长度一样,再一个一个字符串比较
代码:
class Solution {
public:
bool backspaceCompare(string s, string t) {
// 对于每一个字符串,都使用双指针来处理,遇到退格,指针low就回退一步,最终结果以low指针为结尾。
// 两个字符串在一起比较,如果两个长度不一样,直接返回false,否则,长度一样,再一个一个字符串比较
// 对字符串s进行处理
int low1 = 0, fast1 = 0;
while (fast1 < s.length()) {
if (s[fast1] == '#') {
if (low1 > 0) { // low最小就是0的位置,不能再往回退了eg:s="#a#c"
low1--;
}
} else {
s[low1++] = s[fast1];
}
fast1++;
}
// 对字符串t进行同样的处理
int low2 = 0, fast2 = 0;
while (fast2 < t.length()) {
if (t[fast2] == '#') {
if (low2 > 0) { // low最小就是0的位置,不能再往回退了
low2--;
}
} else {
t[low2++] = t[fast2];
}
fast2++;
}
// 比较两个字符串
if (low1 != low2) {
return false;
}
for (int i = 0; i < low1; i++) {
if (s[i] != t[i]) {
return false;
}
}
return true;
}
};
方法二:栈,空间复杂度为O(2n)
这里直接使用字符串string,来作为栈,末尾添加和弹出,string都有相应的接口,最后比较的时候,只要比较两个字符串就可以了,比比较栈里的元素方便一些。
代码:
class Solution {
public:
bool backspaceCompare(string S, string T) {
string s; // 当栈来用
string t; // 当栈来用
for (int i = 0; i < S.size(); i++) {
if (S[i] != '#') s += S[i];
else if (!s.empty()) {
s.pop_back();
}
for (int i = 0; i < T.size(); i++) {
if (T[i] != '#') t += T[i];
else if (!t.empty()) {
t.pop_back();
}
}
if (s == t) return true; // 直接比较两个字符串是否相等,比用栈来比较方便多了
return false;
}
};
2.5 有序数组的平方
链接:977.有序数组的平方
题目:
给你一个按 非递减顺序 排序的整数数组 nums,返回 每个数字的平方 组成的新数组,要求也按 非递减顺序 排序。
总的思路:先平方,然后在排序。
平方之后的数组,以0为界,向两边递增,由于我们得到了两个已经有序的子数组,因此就可以使用归并的方法进行排序了。
方法一:我刚开始的想法:从0开始,从中间向两边扩展,选择最小的元素。
使用两个指针分别指向位置0的两边,每次比较两个指针对应的数,选择较小的那个放入答案并移动指针。当某一指针移至边界时,将另一指针还未遍历到的数依次放入答案。
但是这样比较麻烦,,,
方法二:从两边向中间扩展,不断选择最大的元素。
代码:
class Solution {
public:
vector<int> sortedSquares(vector<int>& nums) {
for (int i = 0; i < nums.size(); i++) {
nums[i] = nums[i] * nums[i];
}
vector<int> result(nums.size(), 0);
// 先平方,然后从0开始从中间分为两半,类似归并排序中的将两个有序数组合并,从中间向两边移动,不断选择最小的元素,
//但是还要找0,看了答案知道这种方法叫做双指针法,换一种合并方法,从两边向中间移动,不断选择两个中最大的放到数组末尾
int i = 0, j = nums.size() - 1, k = nums.size() - 1;
while (i <= j) {
if (nums[i] <= nums[j]) {
result[k--] = nums[j--];
} else {
result[k--] = nums[i++];
}
}
return result;
}
};