简介

双指针算法是一种常见且高效的解决问题的技巧，它通常用于在数组、链表或字符串等数据结构上进行操作。这种算法的核心思想是使用两个指针来遍历数据结构，通常这两个指针具有不同的起始位置或移动速度，从而达到特定的目的。

双指针算法通常有三种常见的应用方式：快慢指针、左右指针和滑动窗口。这些方法的精髓在于，通过灵活地控制指针的移动，可以在不使用额外空间的情况下，以较低的时间复杂度解决许多问题。

快慢指针

快慢指针是双指针算法中的一种常见应用方式，主要用于解决链表中的问题。该算法利用两个指针在链表上以不同的速度移动，从而实现特定的目标。

快慢指针的核心思想是，通过让快指针每次移动两步，慢指针每次移动一步，来在链表上寻找中间节点、检测环或者找到特定的位置等。

常见的应用场景包括：

1. 寻找链表的中间节点：快指针每次移动两步，慢指针每次移动一步，当快指针到达链表末尾时，慢指针所指的位置即为链表的中间节点。

2. 检测链表中是否有环：快慢指针分别以不同的速度在链表上移动，如果存在环，则快指针最终会追上慢指针。

3. 找到环的入口：利用快慢指针检测出环后，通过进一步的计算可以找到环的入口节点。

快慢指针算法的时间复杂度通常为 O(n)，其中 n 是链表的长度。由于只需要常数级别的额外空间，因此该算法是一种高效且节省空间的解决方案。

示例—移动零

示例 1:
输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]示例 2:
输入: nums = [0]
输出: [0]提示:
1 <= nums.length <= 104
-231 <= nums[i] <= 231 - 1

解题步骤

1. 初始化指针：设定两个指针，一个用于遍历数组（可以称为当前指针），另一个指向当前已经处理好的非零元素的最后一个位置（可以称为非零指针）。

2. 遍历数组：从头到尾遍历数组，对于每个元素执行以下操作：

   • 如果当前元素不为零，则将其与非零指针所指位置的元素交换，并将非零指针向后移动一位。

3. 移动零元素：遍历结束后，所有非零元素都被移动到了数组的前部分，剩余的位置就是需要填充零的位置。可以通过非零指针的位置确定需要填充零的起始位置，将其后的所有元素置为零即可。

通过这种方法，我们可以在一次遍历的情况下将数组中的所有零移动到末尾，同时保持非零元素的相对顺序不变。这个方法的时间复杂度是 O(n)，其中 n 是数组的长度。

解题代码

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

代码解析

1. 初始化变量：

   • 使用变量 left 和 right 分别表示数组的起始位置和结束位置。
   • 使用变量 fast 和 low 分别表示当前遍历的位置和最后一个非零元素的位置。

2. 遍历数组：

   • 使用 fast 指针遍历数组。
   • 如果当前位置的元素不为零（即 nums[fast] != 0），则将其与 low 指针指向的元素交换，并将 low 指针向后移动一位。
   • 这样可以保证所有非零元素都被移动到了数组的前部分，而 low 指针之前的位置都是非零元素，low 指针之后的位置都是零元素。

3. 遍历结束后：

   • 所有非零元素都被移动到了数组的前部分，剩余的位置就是需要填充零的位置。

左右指针

左右指针也是双指针算法中的一种常见应用方式，通常用于解决数组或字符串等序列型数据结构中的问题。

该算法使用两个指针，一个从序列的起始位置开始，另一个从序列的末尾位置开始，然后分别向中间移动，根据问题的要求调整指针的移动策略，最终达到解决问题的目的。

常见的应用场景包括：

1. 求两数之和：在有序数组中，通过左右指针分别从两端向中间移动，可以找到两个数使其和等于目标值的情况。

2. 在有序数组中查找特定元素：通过左右指针在有序数组中进行夹逼查找，可以快速定位特定元素的位置。

3. 反转数组或字符串：通过左右指针交换序列中的元素，可以实现数组或字符串的反转操作。

4. 滑动窗口问题：在一个序列中，通过维护一个大小可变的窗口，使用左右指针在序列上滑动，可以有效地解决一些子数组或子字符串相关的问题，如求最小子数组长度等。

左右指针算法通常能够以较低的时间复杂度解决许多问题，而且不需要额外的空间复杂度。因此，在解决数组或字符串相关问题时，左右指针是一种非常有用的技巧。

示例—盛水最多的容器

解题步骤

1. 初始化两个指针 left 和 right，分别指向数组的起始和末尾。
2. 初始化最大水量 ret 为0。
3. 使用双指针向内移动的方式遍历数组：
   • 计算当前容器的水量，即 min(height[left], height[right]) * (right - left)。
   • 更新 ret 的值为当前水量和 ret 中的较大值。
   • 如果 height[left] 大于 height[right]，说明右边界的高度限制了容器的容量，因此将右指针左移一位。
   • 如果 height[left] 小于等于 height[right]，说明左边界的高度限制了容器的容量，因此将左指针右移一位。
4. 当左右指针相遇时，遍历结束，返回 ret。

解题代码

class Solution {
public:int maxArea(vector<int>& height) {int left = 0, right = height.size() - 1;int ret = 0;while(left < right){int value = min(height[left], height[right]) * (right - left);ret = max(ret, value);if(height[left] > height[right]) right--;else left++;}return ret;}
};

代码解析

• 初始化左右指针 left 和 right 分别指向数组的起始和末尾。
• 初始化最大水量 ret 为0，用于存储容器能够容纳的最大水量。
• 使用双指针向内移动的方式遍历数组。
• 在循环中，计算当前容器的水量 value，即 min(height[left], height[right]) * (right - left)，更新 ret 的值为当前水量和 ret 中的较大值。
• 根据当前左右指针所指向的高度情况，决定如何移动指针：如果左边界高度小于等于右边界高度，将左指针右移一位；否则，将右指针左移一位。
• 最终，当左右指针相遇时，返回 ret，即为容器的最大容量。

这个算法的时间复杂度为 O(n)，其中 n 是数组的长度。通过双指针遍历数组一次，找到最大的容器容量。

滑动窗口

滑动窗口是双指针算法的另一种常见应用，通常用于解决数组或字符串中的子数组或子字符串问题。该算法维护一个大小可变的窗口，在序列上滑动，通过调整窗口的起始位置和结束位置，来寻找符合特定条件的子数组或子字符串。

滑动窗口算法的基本思想是利用两个指针，通常是左指针和右指针，来表示窗口的起始位置和结束位置。然后根据问题的要求，移动左右指针，调整窗口的大小和位置，以便寻找满足条件的子数组或子字符串。

常见的应用场景包括：

1. 求解最小子数组长度：在一个包含正整数的数组中，找到和大于或等于给定值的最短连续子数组。

2. 求解最大子数组长度：在一个包含正整数的数组中，找到和小于或等于给定值的最长连续子数组。

3. 字符串匹配：在一个字符串中找到包含另一个字符串的最短连续子串。

4. 求解滑动窗口的最大值或最小值：在一个数组中，找到每个滑动窗口的最大值或最小值。

通过合理地设计滑动窗口的移动策略，可以在时间复杂度为 O(n) 的情况下解决许多问题，其中 n 是数组或字符串的长度。滑动窗口算法通常能够在不使用额外空间的情况下，高效地解决问题，因此在实际应用中非常有用。

示例—长度最小的子数组

示例 1：输入：target = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。
示例 2：输入：target = 4, nums = [1,4,4]
输出：1
示例 3：输入：target = 11, nums = [1,1,1,1,1,1,1,1]
输出：0提示：1 <= target <= 109
1 <= nums.length <= 105
1 <= nums[i] <= 105

解题步骤

这段代码实现的是寻找数组中的最短连续子数组，使得子数组的元素之和至少为给定的目标值 target。如果存在多个这样的子数组，则返回长度最小的子数组长度。如果不存在，则返回 0。这个问题通常通过滑动窗口算法来解决，让我们一步步分析这段代码：

解题步骤

1. 初始化：定义两个指针 left = 0 和 right = 1 作为滑动窗口的边界，初始化一个长整型变量 count = nums[left] 来存储当前窗口内元素的和，以及 minlength = INT_MAX 用于存储满足条件的最短长度。

2. 滑动窗口：使用一个 while 循环，条件为 left < nums.size()，确保左指针不会超出数组范围。

3. 窗口内元素之和满足条件：如果 count >= target，说明当前窗口内的元素之和已经达到或超过了目标值 target。此时，更新 minlength 为 min(minlength, right - left) 来尝试获取最小长度，并通过 count -= nums[left++] 更新窗口内元素的和，同时向右移动左指针。

4. 窗口内元素之和不满足条件：如果 count < target，则需要扩大窗口以包含更多元素，尝试增加窗口内元素之和。这是通过检查 right < nums.size() 来确保右指针不会超出数组范围，然后将 nums[right] 加到 count 上，并向右移动右指针。

5. 循环终止条件：如果右指针已经达到数组末尾，且窗口内的元素之和仍然小于目标值，则退出循环。

6. 返回结果：最后，如果 minlength 仍为 INT_MAX，说明没有找到满足条件的子数组，返回 0；否则，返回找到的最短长度 minlength。

解题代码

class Solution {
public:int minSubArrayLen(int target, vector<int>& nums) {int left = 0, right = 1, minlength = INT_MAX;long long count = nums[left];while(left < nums.size()){if(count >= target) {minlength = min(minlength, right - left);count -= nums[left++];}else {if(right < nums.size())count += nums[right++];else break;}}return minlength == INT_MAX ? 0 : minlength;}
};

代码解析

代码中有几个需要注意的点：

• 滑动窗口：通过左右指针 left 和 right 实现滑动窗口的动态调整。这种方法能够有效地在 O(n) 时间复杂度内解决问题。
• 更新条件：根据当前窗口内元素之和与目标值 target 的比较结果，决定是移动左指针缩小窗口还是移动右指针扩大窗口。
• 边界检查：在扩大窗口时，需要检查 right < nums.size() 来防止右指针越界。