leetcode双指针法常见题目

kirei12315

已于 2023-05-02 21:50:06 修改

阅读量43

点赞数

分类专栏： leetcode刷题文章标签： leetcode 算法职场和发展 Powered by 金山文档

于 2023-02-06 00:34:19 首次发布

本文链接：https://blog.csdn.net/kirei12315/article/details/128895232

版权

leetcode刷题专栏收录该内容

9 篇文章 0 订阅

订阅专栏

移除元素

https://leetcode.cn/problems/remove-element/

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

思路：通过两个指向均为第零个数值的双指针的不同快慢变化来进行选取删除数组，此题考验了双指针同一个开头的用法。

代码如下：

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        //int FastIndex = 0;
        int SlowIndex= 0;
        for(int FastIndex = 0;FastIndex < nums.size();FastIndex++){
            if(nums[FastIndex] != val){
                nums[SlowIndex] = nums[FastIndex];
                SlowIndex ++;
            }
        }
        return SlowIndex;
    }
};

移除元素

给你一个升序排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。元素的相对顺序应该保持一致。

思路：和上一题一样，使用快慢指针，快指针先行遍历，遇到了不同的就把值赋值给慢的，注意赋值后快慢指针加一。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if (n == 0) {
            return 0;
        }
        int fast = 1, slow = 1;
        while (fast < n) {
            if (nums[fast] != nums[fast - 1]) {
                nums[slow] = nums[fast];
                ++slow;
            }
            ++fast;
        }
        return slow;
    }
};
//方法2：
class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if(nums.size() == 0) return 0;
        int slow = 0;
        for(int fast = 1; fast < nums.size(); fast++){
            if(nums[fast] != nums[slow]){
                nums[++slow] = nums[fast];
            }

        }
        return ++slow;//注意这里slow实际上是慢指针移动的次数，要是考虑慢指针的数值，还需要加一。

    }
};

移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

思路：

非0，交换数据，左右指针都往右移

0，右指针右移

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n = nums.size(), left = 0, right = 0;
        while (right < n) {
            if (nums[right]) {
                swap(nums[left], nums[right]);
                left++;
            }
            right++;
        }
    }
};

比较含退格的字符串

给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

一个字符是否会被删掉，只取决于该字符后面的退格符，而与该字符前面的退格符无关。因此当我们逆序地遍历字符串，就可以立即确定当前字符是否会被删掉。

class Solution {
public:
    bool backspaceCompare(string S, string T) {
        int i = S.length() - 1, j = T.length() - 1;
        int skipS = 0, skipT = 0;

        while (i >= 0 || j >= 0) {
            while (i >= 0) {
                if (S[i] == '#') {
                    skipS++, i--;
                } else if (skipS > 0) {
                    skipS--, i--;
                } else {
                    break;
                }
            }
            while (j >= 0) {
                if (T[j] == '#') {
                    skipT++, j--;
                } else if (skipT > 0) {
                    skipT--, j--;
                } else {
                    break;
                }
            }
            if (i >= 0 && j >= 0) {
                if (S[i] != T[j]) {
                    return false;
                }
            } else {
                if (i >= 0 || j >= 0) {
                    return false;
                }
            }
            i--, j--;
        }
        return true;
    }
};

方法2：

建立比较函数，从前往后遍历，仍然使用快慢指针的方式。

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        return deletebackspace(s) == deletebackspace(t);
    }
    string deletebackspace(string s){
        int slow = 0;
        int fast = 0;
        while(fast < s.length()){
            if(s[fast] != '#'){
                s[slow++] = s[fast++];
            }
            if(s[fast] == '#' && slow == 0){
                fast++;
            }
            if(s[fast] == '#' && slow > 0){
                slow--;
                fast++;
            }
        }
        return s.substr(0,slow);
    }
};

有序数组的平方

给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。

思路：双指针一前一后往中间遍历。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& A) {
        int k = A.size() - 1;
        vector<int> result(A.size(), 0);
        for (int i = 0, j = A.size() - 1; i <= j;) { // 注意这里要i <= j，因为最后要处理两个元素
            if (A[i] * A[i] < A[j] * A[j])  {
                result[k--] = A[j] * A[j];
                j--;
            }
            else {
                result[k--] = A[i] * A[i];
                i++;
            }
        }
        return result;
    }
};

长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int result = INT32_MAX;
        int sum = 0; // 滑动窗口数值之和
        int i = 0; // 滑动窗口起始位置
        int subLength = 0; // 滑动窗口的长度
        for (int j = 0; j < nums.size(); j++) {
            sum += nums[j];
            // 注意这里使用while，每次更新 i（起始位置），并不断比较子序列是否符合条件
            while (sum >= s) {
                subLength = (j - i + 1); // 取子序列的长度
                result = result < subLength ? result : subLength;
                sum -= nums[i++]; // 这里体现出滑动窗口的精髓之处，不断变更i（子序列的起始位置）
            }
        }
        // 如果result没有被赋值的话，就返回0，说明没有符合条件的子序列
        return result == INT32_MAX ? 0 : result;
    }
};

水果承篮

思路：双指针滑动窗口搭配哈希表查找：

代码

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        unordered_map<int, int> map;
        int left = 0;
        int ans = 0;
        for(int right = 0; right < fruits.size(); ++right){
            ++map[fruits[right]];
            while(map.size() > 2){
                auto it = map.find(fruits[left]);
                it -> second--;
                if(it -> second == 0){
                    map.erase(fruits[left]);
                }
                ++left;
            }
            ans = max(ans,right - left + 1);
        }
        return ans;

    }
};

最小覆盖子串

class Solution {
public:
    string minWindow(string s, string t) {
        unordered_map<int, int> ss,ts;
        for(auto c : t){
            ts[c]++;
        }
        int slow = 0;
        int count = 0;
        string result;
        for(int fast = 0; fast < s.size(); fast++){
            ss[s[fast]]++;
            if(ss[s[fast]] <= ts[s[fast]]) count ++;
            while(ss[s[slow]] > ts[s[slow]]) ss[s[slow++]]--;
            if(count == t.size()){
                if(result.empty() || fast - slow + 1 < result.size()){
                    result = s.substr(slow,fast - slow + 1);
                }
            }
        }
        return result;


    }
};

三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为： [ [-1, 0, 1], [-1, -1, 2] ]

思路：在这里卡哥的思路已经非常明确了：https://programmercarl.com/0015.%E4%B8%89%E6%95%B0%E4%B9%8B%E5%92%8C.html#%E5%8F%8C%E6%8C%87%E9%92%88我就不在重复了。

代码如下：

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for(int i = 0; i < nums.size();i++){
            if(nums[i] > 0) return result;
            if(i > 0 && nums[i] == nums[i - 1]) continue;
            int left = i + 1;
            int right = nums.size() - 1;
            while(left < right){
                if(nums[i] + nums[left] + nums[right] > 0) right--;
                else if(nums[i] + nums[left] + nums[right] < 0) left++;
                else{
                    result.push_back(vector<int>{nums[i], nums[left], nums[right]});
                    while (right > left && nums[right] == nums[right - 1]) right--;
                    while (right > left && nums[left] == nums[left + 1]) left++;
                    right--;
                    left++;

                }
                }
            }
        

    return result;
    }
};

有一点值得注意，那就是if循环，if和else if是有差别的，差别可参考这篇文章：

https://blog.csdn.net/Littlehero_121/article/details/102723434?spm=1001.2101.3001.6661.1&utm_medium=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-102723434-blog-123664235.pc_relevant_multi_platform_whitelistv3&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-1-102723434-blog-123664235.pc_relevant_multi_platform_whitelistv3&utm_relevant_index=1

#include <iostream>
#include <string>
#include <stdio.h>
using namespace std;
 
//以下就是通过if语句来看出不同
int main()
{
    int i = 1;
    if (i == 1)
    {
        i++;
        cout << "i =" << i;
    }
    if (i == 2)
    {
        i++;
        cout << "i = " << i;
    }
    if (i == 3)
    {
        i++;
        cout << "i =" << i;
    }
    while (1);
    return 0;
}
 
 
//以下就是通过else if语句来看出来有什么不同的地方
int main()
{
    int i = 1;
    if (i == 1)
    {
        i++;
        cout << "i =" << i;
    }
    else if (i == 2) //满足条件，但是不会执行
    {
        i++;
        cout << "i = " << i;
    }
    else if (i == 3)//满足条件，但是不会执行
    {
        i++;
        cout << "i =" << i;
    }
    while (1);
    return 0;
}

四数之和

题意：给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

和三数之和一样的思路，区别是使用了两层for循环用来处理k和i

class Solution {
public:
    vector<vector<int>> fourSum(vector<int>& nums, int target) {
        vector<vector<int>> result;
        sort(nums.begin(), nums.end());
        for (int k = 0; k < nums.size(); k++) {
            // 剪枝处理
            if (nums[k] > target && nums[k] >= 0) {
                break; // 这里使用break，统一通过最后的return返回
            }
            // 对nums[k]去重
            if (k > 0 && nums[k] == nums[k - 1]) {
                continue;
            }
            for (int i = k + 1; i < nums.size(); i++) {
                // 2级剪枝处理
                if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
                    break;
                }

                // 对nums[i]去重
                if (i > k + 1 && nums[i] == nums[i - 1]) {
                    continue;
                }
                int left = i + 1;
                int right = nums.size() - 1;
                while (right > left) {
                    // nums[k] + nums[i] + nums[left] + nums[right] > target 会溢出
                    if ((long) nums[k] + nums[i] + nums[left] + nums[right] > target) {
                        right--;
                    // nums[k] + nums[i] + nums[left] + nums[right] < target 会溢出
                    } else if ((long) nums[k] + nums[i] + nums[left] + nums[right]  < target) {
                        left++;
                    } else {
                        result.push_back(vector<int>{nums[k], nums[i], nums[left], nums[right]});
                        // 对nums[left]和nums[right]去重
                        while (right > left && nums[right] == nums[right - 1]) right--;
                        while (right > left && nums[left] == nums[left + 1]) left++;

                        // 找到答案时，双指针同时收缩
                        right--;
                        left++;
                    }
                }

            }
        }
        return result;
    }
};

kirei12315

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
leetcode双指针法常见题目

移除元素给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。思路：通过两个指向均为第零个数值的双指针的不同快慢变化来进行选取删除数组，此题考验了双指针同一个开头的用法。移除元素给你一个升序排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。元素的相对顺序应该保持一致。思路：和上一题一样，使用快慢指针，快指针先行遍历，遇到了不同的就把值赋值给慢的，注意赋值后快慢指针加一。
复制链接

扫一扫