本文介绍了多种使用二分查找和双指针策略解决的编程问题，包括寻找有序数组中的目标值、找寻错误版本、搜索插入位置等。这些算法在时间复杂度上要求高效，如二分查找通常为O(logn)。此外，文章还涉及链表操作和数组旋转等数据结构问题，以及如何优化代码以减少API调用次数。通过对这些经典问题的解析，读者可以深入理解并掌握这些常用算法。
文章目录
双指针
深度优先搜索 双指针 二分查找
在数学和计算机科学之中，算法是一个被定义好的、计算机可施行之指示的有限步骤或次序，常用于计算、数据处理和自动推理。作为一个有效方法，算法被用于计算函数，它包含了一系列定义清晰的指令，并可于有限的时间及空间内清楚的表述出来。
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
思路：
代码：
class Solution {
public:
int search(vector<int>& nums, int target) {
int l = nums.size()-1;
int low=0 , high= l ;
while(low <= high){
int mid = (low + high )/2 ;
if(nums[mid] == target )
return mid;
else if(nums[mid] < target)
low = mid +1;
else if (nums[mid] > target)
high = mid -1;
};
return -1;
}
};
278.第一个错误的版本
你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。
假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。
你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。
示例 1：
输入： n = 5, bad = 4
输出： 4
解释：
调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。
示例 2：
输入： n = 1, bad = 1
输出： 1
思路：
代码：
// The API isBadVersion is defined for you.
// bool isBadVersion(int version);
class Solution {
public:
int firstBadVersion( int n) {
long long int low = 1, high = n;
long long int mid;
while(low <= high){
mid = (low + high )/2;
if(isBadVersion(mid) == false)
low = mid + 1;
else
{
if(isBadVersion(mid-1) == false)
return mid;
else
high = mid - 1;
}
}
return mid;
}
};
35.搜索插入位置
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
请必须使用时间复杂度为 O(log n) 的算法。
示例 1:
输入: nums = [1,3,5,6], target = 5
输出: 2
示例 2:
输入: nums = [1,3,5,6], target = 2
输出: 1
示例 3:
输入: nums = [1,3,5,6], target = 7
输出: 4
示例 4:
输入: nums = [1,3,5,6], target = 0
输出: 0
示例 5:
输入: nums = [1], target = 0
输出: 0
提示:
1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 为无重复元素的升序排列数组
-104 <= target <= 104
思路：
代码：
class Solution {
public:
int searchInsert(vector<int>& nums, int target) {
int low , high , mid;
low = 1 ;
high = nums.size()-1;
if(nums[0] >= target) //小于等于第一个
return 0;
else if (nums[high] < target) // 大与最后一个
return high+1;
else{ //位于最大最小之间
while(low <= high){
mid = (low + high )/2;
if(nums[mid] < target) // 中间值小于目标数
low = mid + 1;
else if(nums[mid] > target )//中间值大与目标数
high = mid - 1;
else
return mid;
}
}
return low;//这里要返回low，而不是返回mid，具体细节可以通过样例[1,2,4,6,7],3 手动模拟理解
}
};
977.有序数组的平方
class Solution {
public:
vector<int> sortedSquares(vector<int>& nums) {
int l = nums.size();
int x[10005];
for(int i = 0 ; i < l ; i ++ )
{
x[i] = nums[i]*nums[i];
}
sort(x, x+l );
for(int i = 0 ; i < l ; i ++ )
{
nums[i] = x[i] ;
}
return nums;
}
};
189.旋转数组
class Solution {
public:
void rotate(vector<int>& nums, int k) {
int x[200005];
int l = nums.size();
k %= l;
for(int i = 0 ; i < l-k ; i ++)
x[i+k] = nums[i];
for(int i = 0 ; i < k ; i ++)
x[i] = nums[l-k+i];
for(int i = 0 ; i < l ; i ++ )
nums[i] = x[i];
}
};
283.移动零
class Solution {
public:
void moveZeroes(vector<int>& nums) {
int zero = 0;
int x = 0;
for(int i = 0 ; i < nums.size() ; i ++)
{
if(nums[i] == 0 )
zero++;
else{
nums[x] = nums[i] ;
x++;
}
}
for(int i = x ; i < nums.size() ; i ++)
nums[i] = 0;
}
};
344.反转字符串
class Solution {
public:
void reverseString(vector<char>& s) {
reverse(s.begin(), s.end());
}
};
总结： 本来自己写了一堆还没有调通，看了一眼评论立马吐血（虽然是直接调用别人的库，但自己还是孤弱寡闻了）
876.链表的中间结点
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* middleNode(ListNode* head) {
ListNode *x1,*x2;
x1 = head;
int i = 1;
while(x1 != NULL)
{
x1 = x1->next;
i++;
}
i--;
x1 = head;
for(int j = 1 ; j <= i/2 ; j ++)
{
x1 = x1->next;
}
return x1;
}
};
总结： 学习了链表的基本操作方法
19.删除链表的倒数第N个结点
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
//笨办法：跑一遍算算总共有多少个节点，然后再跑一遍找到对应的待删除结点删除
ListNode *x1;
x1 = head;
int a=0;
while(x1 !=NULL){
x1 = x1->next;
a++;
}
//cout<<a;
if(a>2){
a -= n;
if(a == 0 )
head = head -> next;
else
{
x1 = head;
while(a >1 ){
x1 = x1 ->next;
a--;
}
x1->next = x1->next->next;
}
}
else if (a == 2 ){
if(n == 2)
head = head->next;
else
head->next = NULL;
}
else
head = NULL;
return head;
}
};
总结： 还需要改善为直接一趟完成
392.判断子序列
给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
输入：s = “abc”, t = “ahbgdc”
输出：true
输入：s = “axc”, t = “ahbgdc”
输出：false
class Solution {
public:
bool isSubsequence(string s, string t) {
int n = s.length(), m = t.length();
int l = 0;
int i = 0 , j = 0 ; //i指向s，j指向t
while(1){
if(i == n){ //当s已经到最后一个元素的后一位，即s为t的子序列，true
l = 1;
break;
}
if(j == m) //当t已经到最后一个元素的后一位，即t已全部遍历完，false
break;
if(s[i] == t[j]){ //指向s的元素和指向t的元素相同，同时向后移一位
i++;
j++;
}
else //不同时，t向后移一位
j ++;
}
if(l == 1)
return true;
else
return false;
}
};
15.三数之和
给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
扫一扫
260
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
