【刷题总结】双指针法 | 解决数组问题（C++实现）

写在前面：
🌟 欢迎光临 清流君 的博客小天地，这里是我分享技术与心得的温馨角落。📝


🎭 人生如戏，我们并非能选择舞台和剧本，但我们可以选择如何演绎 🌟
感谢您的支持与关注，让我们一起在知识的海洋中砥砺前行~~~

文章目录

• 一、双指针法简介
• 二、常见用途

• 1、有序数组的两数之和
• 2、 快慢指针
• 3、滑动窗口
• 4、删除元素

• 三、示例程序

• 1、有序数组两数之和
• 2、有序数组的平方
• 3、移除元素
• 4、滑动窗口

• 参考资料

---

一、双指针法简介

  双指针法是一种在数组或链表等线性数据结构上进行操作的算法技巧。
  通常涉及两个指针，这两个指针以不同的速度移动，或者向不同的方向移动，以达到特定的目的，如搜索、排序、删除、插入元素。

---

二、常见用途

1、有序数组的两数之和

  在一个已排序的数组中找到两个数，使它们的和等于一个特定的目标值。两个指针可以从数组的两端开始，根据当前两个数的和与目标值的关系，向中间移动。

2、 快慢指针

  在链表中查找环或进行分割。一个指针（慢指针）每次移动一步，另一个指针（快指针）每次移动两步。如果快指针追上慢指针，则可能存在环。

3、滑动窗口

  在数组或字符串中查找一个包含特定性质的最小子数组或子字符串。两个指针定义了窗口的边界，它们根据窗口内的元素特性向右滑动。

4、删除元素

  在数组中删除特定值的所有实例。两个指针可以用来重排数组，一个指针用于遍历，另一个指针用于指向下一个应该填充的位置。

---

三、示例程序

1、有序数组两数之和

在有序数组中找到两个数，使它们的和等于一个特定的目标值。

C++代码如下：

登录后复制

#include <iostream>
#include <vector>
using namespace std;

vector<int> twoSum(vector<int>& numbers, int target) {
    int left = 0, right = numbers.size() - 1;
    while (left < right) {
        int sum = numbers[left] + numbers[right];
        if (sum == target) {
            return {left + 1, right + 1};  // 返回 1-based 索引
        } else if (sum < target) {
            left++;  // 增加左指针以增加和
        } else {
            right--;  // 减少右指针以减少和
        }
    }
    return {-1, -1};  // 如果没有找到，返回无效的索引
}

int main() {
    vector<int> numbers = {2, 7, 11, 15};
    int target = 9;
    vector<int> result = twoSum(numbers, target);
    cout << "Index1: " << result[0] << ", Index2: " << result[1] << endl;
    return 0;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.

  在这个例子中，left 和 right 是两个指针，它们分别从数组的两端开始，向中间移动，直到找到两个数的和等于目标值，或者两个指针相遇。

2、有序数组的平方

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

• 示例 1：
  输入：nums = [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]
• 示例 2：
  输入：nums = [-7,-3,2,3,11] 输出：[4,9,9,49,121]

---

• 解法：
    数组其实是有序的， 只不过负数平方之后可能成为最大数了。
    那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。
    此时可以考虑双指针法了， 指向起始位置，

  定义一个新数组result，和 数组一样的大小，让k指向result数组终止位置。
  如果A[i] * A[i] < A[j] * A[j] 那么result[k--] = A[j] * A[j]; 。
  如果A[i] * A[i] >= A[j] * A[j] 那么result[k--] = A[i] * A[i]; 。

C++代码如下：

登录后复制

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int k = nums.size() - 1;
        vector<int> result(nums.size());
        for (int i = 0, j = nums.size() - 1; i <= j;) {
            if (nums[i] * nums[i] <= nums[j] * nums[j]) {
                result[k--] = nums[j] * nums[j];
                j--;
            } else {
                result[k--] = nums[i] * nums[i];
                i++;
            }
        }
        return result;
    }
};

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.

3、移除元素

 Leetcode题目链接

• 给一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
• 不要使用额外的数组空间，你必须仅使用
• 元素的顺序可以改变，不需要考虑数组中超出新长度后面的元素。

• 示例 1:
  给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 , 并且 nums 中的前两个元素均为 。 不需要考虑数组中超出新长度后面的元素。
• 示例 2:
  给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 , 并且 nums 中的前五个元素为 。

---

• 解法：
    使用双指针法（快慢指针法），通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

定义快慢指针

• 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
• 慢指针：指向更新 新数组下标的位置

C++代码如下：

登录后复制

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

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.

4、滑动窗口

 Leetcode题目链接

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

• 示例：
  输入：s = 7, nums = [2,3,1,2,4,3] 输出：
  解释：子数组
• 要求：
  
  
  

---

• 解法：
    使用数组操作中另一个重要的方法：滑动窗口。
    所谓滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。

那么滑动窗口如何用一个for循环来完成这个操作呢?

  首先要思考 如果用一个for循环，那么应该表示 滑动窗口的起始位置，还是终止位置。

如果只用一个for循环来表示 滑动窗口的起始位置，那么如何遍历剩下的终止位置？

  此时难免再次陷入 暴力解法的怪圈。
  所以 只用一个for循环，那么这个循环的索引，一定是表示 滑动窗口的终止位置。

那么问题来了， 滑动窗口的起始位置如何移动呢？

， 数组是 来看一下查找的过程：

  最后找到 是最短距离。

  其实从动画中可以发现滑动窗口也可以理解为双指针法的一种！只不过这种解法更像是一个窗口的移动，所以叫做滑动窗口更适合一些。

在本题中实现滑动窗口，主要确定如下三点：

• 窗口内是什么？
• 如何移动窗口的起始位置？
• 如何移动窗口的结束位置？

窗口
  就是满足其和 的长度最小的 连续子数组。

窗口的起始位置如何移动：
  如果当前窗口的值大于等于

窗口的结束位置如何移动：
  窗口的结束位置就是遍历数组的指针，也就是for循环里的索引。

解题的关键在于 窗口的起始位置如何移动，如图所示：

  可以发现滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将 暴力解法降为 。

C++代码如下：

登录后复制

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;
    }
};

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.

---

参考资料

   代码随想录

---

后记：

🌟 感谢您耐心阅读这篇关于 双指针法 | 解决数组问题 的技术博客。 📚

🎯 如果您觉得这篇博客对您有所帮助，请不要吝啬您的点赞和评论 📢

🌟您的支持是我继续创作的动力。同时，别忘了收藏本篇博客，以便日后随时查阅。🚀

🚗 让我们一起期待更多的技术分享，共同探索移动机器人的无限可能！💡

🎭感谢您的支持与关注，让我们一起在知识的海洋中砥砺前行 🚀

原创作者: u_16954161 转载于: https://blog.51cto.com/u_16954161/11784889