力扣刷题之双指针
双指针：
- 快慢指针
- 逆向双指针
- 二分查找
- 滑动窗口
16.最接近的三数之和（排序+双指针）
class Solution {
public:
int threeSumClosest(vector<int>& nums, int target) {
int len=nums.size(),min_distance=INT_MAX,ans;
sort(nums.begin(),nums.end());
for(int i=0;i<len;i++){
int head=i+1,tail=len-1;
while(head<tail){
int sum=nums[i]+nums[head]+nums[tail];
int tmp=sum-target;
if(tmp>0)
tail--;
if(tmp<0)
head++;
if(tmp==0)
return sum;
if(abs(tmp)<abs(min_distance)){
min_distance=tmp;
ans=sum;
}
}
}
return ans;
}
};
18.四数之和（排序+双指针）
class Solution {
public:
vector<vector<int>> fourSum(vector<int>& nums, int target) {
sort(nums.begin(),nums.end());//忘了排序呜呜
vector<vector<int>> result;
if(nums.size()<4)
return result;//记得判断一下数组是不是有4个数
for(int a=0;a<nums.size()-3;a++){
if(a>0&&nums[a]==nums[a-1])continue;//确保nums[a]变了，下同理
for(int b=a+1;b<nums.size()-2;b++){
if(b>a+1&&nums[b]==nums[b-1])continue;
int c=b+1,d=nums.size()-1;
while(c<d){
// if(nums[a]+nums[b]+nums[c]+nums[d]>target)d--;
// else if(nums[a]+nums[b]+nums[c]+nums[d]<target)c++;int溢出
if(nums[c]+nums[d]>target-nums[a]-nums[b])d--;
else if(nums[c]+nums[d]<target-nums[a]-nums[b])c++;
else{
result.push_back({nums[a],nums[b],nums[c],nums[d]});//这里括号忘记了，淦
while(c<d&&nums[c+1]==nums[c])c++;//没用循环判断，注意和上面判断的区别，下同
while(c<d&&nums[d-1]==nums[d])d--;
c++;//忘了
d--;//忘了
}
}
}
}
return result;
}
};
31.下一个排列（双指针）
class Solution {
public:
void nextPermutation(vector<int>& nums) {
int i = nums.size() - 2;
while (i >= 0 && nums[i] >= nums[i + 1]) {
i--;
}
if (i >= 0) {
int j = nums.size() - 1;
while (j >= 0 && nums[i] >= nums[j]) {
j--;
}
swap(nums[i], nums[j]);
}
reverse(nums.begin() + i + 1, nums.end());
}
};
33.搜索旋转排序数组（二分查找）
要求时间复杂度为O（logn)
分为两部分，这两部分是分别局部有序的，所以先根据nums[0]和nums[mid]的相对大小来判断是前半部分有序还是后半部分有序，然后在有序的部分采用二分查找
class Solution {
public:
int search(vector<int>& nums, int target) {
int n = (int)nums.size();
if (!n) {
return -1;
}
if (n == 1) {
return nums[0] == target ? 0 : -1;
}
int l = 0, r = n - 1;
while (l <= r) {
int mid = (l + r) / 2;
if (nums[mid] == target) return mid;
if (nums[0] <= nums[mid]) {
if (nums[0] <= target && target < nums[mid]) {
r = mid - 1;
} else {//注意else不能省
l = mid + 1;
}
} else {
if (nums[mid] < target && target <= nums[n - 1]) {
l = mid + 1;
} else {
r = mid - 1;
}
}
}
return -1;
}
};
88.合并两个有序数组（双指针）
因为nums1后半部分是空的所以采用逆向双指针比较，不用开辟额外的空间
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
int p1 = m - 1, p2 = n - 1;
int tail = m + n - 1;
int cur;
while (p1 >= 0 || p2 >= 0) {
if (p1 == -1) {
cur = nums2[p2--];
} else if (p2 == -1) {
cur = nums1[p1--];
} else if (nums1[p1] > nums2[p2]) {
cur = nums1[p1--];
} else {
cur = nums2[p2--];
}
nums1[tail--] = cur;
}
}
};
142.环形链表II
法一：哈希表
我们遍历链表中的每个节点，并将它记录下来；一旦遇到了此前遍历过的节点，就可以判定链表中存在环。借助哈希表可以很方便地实现。
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
unordered_set<ListNode *> visited;
while (head != nullptr) {
if (visited.count(head)) {
return head;
}
visited.insert(head);
head = head->next;
}
return nullptr;
}
};
法二：快慢指针
对于链表找环路的问题，有一个通用的解法——快慢指针（Floyd 判圈法）。给定两个指针，分别命名为 slow 和 fast，起始位置在链表的开头。每次 fast 前进两步，slow 前进一步。如果 fast可以走到尽头，那么说明没有环路；如果 fast 可以无限走下去，那么说明一定有环路，且一定存在一个时刻 slow 和 fast 相遇。当 slow 和 fast 第一次相遇时，我们将 fast 重新移动到链表开头，并让 slow 和 fast 每次都前进一步。当 slow 和 fast 第二次相遇时，相遇的节点即为环路的开始点。
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode *slow = head, *fast = head;
while (fast != nullptr) {
slow = slow->next;
if (fast->next == nullptr) {
return nullptr;
}
fast = fast->next->next;
if (fast == slow) {
ListNode *ptr = head;
while (ptr != slow) {
ptr = ptr->next;
slow = slow->next;
}
return ptr;
}
}
return nullptr;
}
};
76.最小覆盖子串（hard不愧是hard，瑞斯拜）
本题的关键在于如何高效的判断t中各个字符已经包含在窗口当中，如果每调整一次窗口就去遍历t串检查则会超时。于是使用count变量，实时记录窗口中已存在的，t中必须要有的字符数量,一旦该值与t串的大小相等，则满足要求，可以进一步进行收缩操作。
可以用滑动窗口的思想解决这个问题。在滑动窗口类型的问题中都会有两个指针，一个用于「延伸」现有窗口的 r指针，和一个用于「收缩」窗口的l 指针。在任意时刻，只有一个指针运动，而另一个保持静止。我们在 s 上滑动窗口，通过移动 r指针不断扩张窗口。当窗口包含 tt全部所需的字符后，如果能收缩，我们就收缩窗口直到得到最小窗口。
如何判断当前的窗口包含所有 t所需的字符呢？我们可以用一个哈希表表示 t中所有的字符以及它们的个数，用一个哈希表动态维护窗口中所有的字符以及它们的个数，如果这个动态表中包含 t的哈希表中的所有字符，并且对应的个数都不小于 t 的哈希表中各个字符的个数，那么当前的窗口是「可行」的。
注意：这里 t 中可能出现重复的字符，所以我们要记录字符的个数。
class Solution {
public:
string minWindow(string s, string t) {
if(s.size()<t.size()) return "";
unordered_map<char,int> ws; //记录s串各个字母的数量
unordered_map<char,int> wt; //记录t串各个字母的数量
int slow=0;
int count=0; //记录窗口中（slow和fast区间内）已包含t串字符的数量
string result;
for(int i=0;i<t.size();i++){ //遍历t串保存其各个字母的数量
wt[t[i]]++;
}
for(int fast=0;fast<s.size();fast++){ //fast指针遍历s串
ws[s[fast]]++;
if(ws[s[fast]]<=wt[s[fast]]) count++; //如果当前窗口中该字母的数量还未达到t中的数量要求，则必须加入
while(count==t.size()){ //count=t.size()即窗口中全部满足t的各个字母的数量要求
int len=fast-slow+1;
if(result.size()==0||len<result.size()){ //要考虑第一次的情况
result.clear();
result=s.substr(slow,len);
}
ws[s[slow]]--;
if(ws[s[slow]]<wt[s[slow]]) count--; //slow指针进行收缩，一旦必须要求的字母数量减少，count--
slow++;
}
}
return result;
}
};
633.平方数之和
//法一
class Solution {
public:
bool judgeSquareSum(int c) {
for (long a = 0; a * a <= c; a++) {
double b = sqrt(c - a * a);
if (b == (int)b) {
return true;
}
}
return false;
}
};
//法二：双指针
class Solution {
public:
bool judgeSquareSum(int c) {
long left = 0;
long right = (int)sqrt(c);
while (left <= right) {
long sum = left * left + right * right;
if (sum == c) {
return true;
} else if (sum > c) {
right--;
} else {
left++;
}
}
return false;
}
};
680.验证回文字符串II
双指针
class Solution {
public:
bool validPalindrome(string s) {
int n=s.size();
int i=0,j=n-1;
while(i<j){
if(s[i]!=s[j]){
for(int k=0;k<2;k++){
if(k==0){
if(isok(i+1,j,s))return true;
}else if(k==1){
if(isok(i,j-1,s))return true;
}
}
return false;
}
i++,j--;
}
return true;
}
bool isok(int i,int j,string &s){
while(i<j){
if(s[i]!=s[j])return false;
i++,j--;
}
return true;
}
};
524.通过删除字母匹配到字典里最长的单词
class Solution {
public:
string findLongestWord(string s, vector<string> & dictionary) {
//字符串的长度从大到小排序，且字符串符合字典序
auto cmp = [&] (string& a, string& b)
{
if (a.size() == b.size()) {
return a < b;
}
return a.size() > b.size();
};
sort(dictionary.begin(), dictionary.end(), cmp);
int s_len = s.size(), d_len = dictionary.size(), ds_len = 0;
int s_ptr = 0, d_ptr = 0;
//双指针方法，遍历字典
for (int i = 0; i < d_len; ++i)
{
ds_len = dictionary[i].size(); //当前字典的字符串的长度
while (s_ptr < s_len && d_ptr < ds_len)
{
if (s[s_ptr] == dictionary[i][d_ptr]) //存在相等的字母
{
if (d_ptr == ds_len - 1) //且已经到达当前字符串的末尾，即存在，因为已经排序，所以第一个符合条件的即为答案
{
return dictionary[i];
}
//当前字典的字符串的下一个字母
++d_ptr;
}
//匹配被查找字符串的下一个字母
++s_ptr;
}
//比较字典的下一个字符串，被查找字符串的s_ptr归零
s_ptr = 0;
//进行字典的下一个字符串比较，d_ptr归零
d_ptr = 0;
}
return "";
}
};
class Solution {
private:
// src是否包含dst这个子序列
bool IsSubsequence(string src, string dst)
{
int ns = src.size();
int nt = dst.size();
int i = 0;
int j = 0;
for (; i < ns && j < nt; ++i)
{
if (src[i] == dst[j])
{
++j;
}
}
return j == nt;
}
public:
string findLongestWord(string s, vector<string>& dictionary) {
// 保存最大的结果
string res = "";
for (string dst : dictionary)
{
if (IsSubsequence(s, dst))
{
// 找到更长的 或者 一样长但是字典序更小
if ((dst.size() > res.size()) || (dst.size() == res.size() && dst < res))
{
res = dst;
}
}
}
return res;
}
};
263
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
