探索效率：解析双指针算法

最新推荐文章于 2024-04-23 16:37:53 发布

拖拉机厂第一代码手

最新推荐文章于 2024-04-23 16:37:53 发布

阅读量703

点赞数 36

分类专栏：数据结构文章标签：算法 c++ c语言

本文链接：https://blog.csdn.net/wzh18907434168/article/details/136082146

版权

数据结构专栏收录该内容

3 篇文章 0 订阅

订阅专栏

简介

在这里插入图片描述

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

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

快慢指针

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

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

常见的应用场景包括：

寻找链表的中间节点：快指针每次移动两步，慢指针每次移动一步，当快指针到达链表末尾时，慢指针所指的位置即为链表的中间节点。
检测链表中是否有环：快慢指针分别以不同的速度在链表上移动，如果存在环，则快指针最终会追上慢指针。
找到环的入口：利用快慢指针检测出环后，通过进一步的计算可以找到环的入口节点。

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

示例—移动零

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

请注意，必须在不复制数组的情况下原地对数组进行操作。

示例 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

进阶：你能尽量减少完成的操作次数吗？

解题步骤

初始化指针：设定两个指针，一个用于遍历数组（可以称为当前指针），另一个指向当前已经处理好的非零元素的最后一个位置（可以称为非零指针）。
遍历数组：从头到尾遍历数组，对于每个元素执行以下操作：
- 如果当前元素不为零，则将其与非零指针所指位置的元素交换，并将非零指针向后移动一位。
移动零元素：遍历结束后，所有非零元素都被移动到了数组的前部分，剩余的位置就是需要填充零的位置。可以通过非零指针的位置确定需要填充零的起始位置，将其后的所有元素置为零即可。

通过这种方法，我们可以在一次遍历的情况下将数组中的所有零移动到末尾，同时保持非零元素的相对顺序不变。这个方法的时间复杂度是 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]);
            }
        }
    }
};

在这里插入图片描述

代码解析

初始化变量：
- 使用变量 left 和 right 分别表示数组的起始位置和结束位置。
- 使用变量 fast 和 low 分别表示当前遍历的位置和最后一个非零元素的位置。
遍历数组：
- 使用 fast 指针遍历数组。
- 如果当前位置的元素不为零（即 nums[fast] != 0），则将其与 low 指针指向的元素交换，并将 low 指针向后移动一位。
- 这样可以保证所有非零元素都被移动到了数组的前部分，而 low 指针之前的位置都是非零元素，low 指针之后的位置都是零元素。
遍历结束后：
- 所有非零元素都被移动到了数组的前部分，剩余的位置就是需要填充零的位置。

左右指针

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

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

常见的应用场景包括：

求两数之和：在有序数组中，通过左右指针分别从两端向中间移动，可以找到两个数使其和等于目标值的情况。
在有序数组中查找特定元素：通过左右指针在有序数组中进行夹逼查找，可以快速定位特定元素的位置。
反转数组或字符串：通过左右指针交换序列中的元素，可以实现数组或字符串的反转操作。
滑动窗口问题：在一个序列中，通过维护一个大小可变的窗口，使用左右指针在序列上滑动，可以有效地解决一些子数组或子字符串相关的问题，如求最小子数组长度等。

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

示例—盛水最多的容器

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明：你不能倾斜容器。

示例 1：
在这里插入图片描述

输入：[1,8,6,2,5,4,8,3,7]
输出：49
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：
输入：height = [1,1]
输出：1

提示：
n == height.length
2 <= n <= 105
0 <= height[i] <= 104

解题步骤

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

滑动窗口

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

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

常见的应用场景包括：

求解最小子数组长度：在一个包含正整数的数组中，找到和大于或等于给定值的最短连续子数组。
求解最大子数组长度：在一个包含正整数的数组中，找到和小于或等于给定值的最长连续子数组。
字符串匹配：在一个字符串中找到包含另一个字符串的最短连续子串。
求解滑动窗口的最大值或最小值：在一个数组中，找到每个滑动窗口的最大值或最小值。

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

示例—长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例 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。这个问题通常通过滑动窗口算法来解决，让我们一步步分析这段代码：

解题步骤

初始化：定义两个指针 left = 0 和 right = 1 作为滑动窗口的边界，初始化一个长整型变量 count = nums[left] 来存储当前窗口内元素的和，以及 minlength = INT_MAX 用于存储满足条件的最短长度。
滑动窗口：使用一个 while 循环，条件为 left < nums.size()，确保左指针不会超出数组范围。
窗口内元素之和满足条件：如果 count >= target，说明当前窗口内的元素之和已经达到或超过了目标值 target。此时，更新 minlength 为 min(minlength, right - left) 来尝试获取最小长度，并通过 count -= nums[left++] 更新窗口内元素的和，同时向右移动左指针。
窗口内元素之和不满足条件：如果 count < target，则需要扩大窗口以包含更多元素，尝试增加窗口内元素之和。这是通过检查 right < nums.size() 来确保右指针不会超出数组范围，然后将 nums[right] 加到 count 上，并向右移动右指针。
循环终止条件：如果右指针已经达到数组末尾，且窗口内的元素之和仍然小于目标值，则退出循环。
返回结果：最后，如果 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;
    }
};