数据结构：双指针法

最新推荐文章于 2024-10-16 22:43:21 发布

OutlierLi

最新推荐文章于 2024-10-16 22:43:21 发布

阅读量306

点赞数 4

分类专栏：数据结构代码随想录文章标签：数据结构 leetcode 算法

本文链接：https://blog.csdn.net/Input_print/article/details/142441287

版权

数据结构同时被 2 个专栏收录

14 篇文章 0 订阅

订阅专栏

代码随想录

9 篇文章 0 订阅

订阅专栏

数据结构：双指针法

双指针法一直是一个强大的工具，目前应用：数组中，二分查找、链表、移除元素、串、数组扩容、KMP算法的next数组、

双指针法不限于某一个具体的数据结构，是一种算法思想

双指针法题目

移除元素

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

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

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

示例 2: 给定 nums = [0,1,2,2,3,0,4,2], val = 2, 函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。

// 双指针法：快慢指针，思想和上面的首尾指针差不多，但是快慢指针可以保证最终顺序是不变的。
// 时间复杂度：O(n)
// 空间复杂度：O(1)
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slowIndex = 0;
        for (int fastIndex = 0; fastIndex < nums.size(); fastIndex++) {
            if (val != nums[fastIndex]) {
                nums[slowIndex++] = nums[fastIndex];
            }
        }
        return slowIndex;
    }
};

暴力破解方法

双指针法

数组中三数之和、四数之和

暴力破解时间复杂度，双指针法时间复杂度

相当于减少了一个for循环

本题：双指针法（快慢指针法）： 通过一个快指针和慢指针在一个for循环下完成两个for循环的工作。

有序数组的平方

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

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        // //暴力破解法：先全部平方，然后排序
        // for(int i = 0; i < nums.size(); i++){
        //     nums[i] *= nums[i];
        // }
        // sort(nums.begin(), nums.end()); //注意快速排序的代码，被封装在了sort中；
        // return nums; //返回排序好的数组；

        // 双指针法：
        // 找不变的量，不变的量是平方之后最大的数一定在两边，比如[-1,0,1,2]中平方后最大的4一定在数组边界上
        // 每次都找到一个最大的量，不能交换，一旦交换，最大的在边界上这一稳定的结果未必成立，所以开辟一个新数组
        /* 右边指针和左边指针比较大小：
            初始状态：左边指针在0，右边指针和k都是nums.size()-1
            两边指针所指元素都平方，然后比较大小
                如果左边大，就平方后放到result数组右边界k上，此时左边指针向右走一位；
                如果右边大，就平方后放到result数组右边界k上，此时右边指针向左走一位；
                完成比较后，result第一个最大元素归位，即第k个元素已经归位（算法是有穷的，每次归位1个元素）
                k指针向左走一个单位
            停止状态：右边指针到达左边指针的位置或者k=0
        */
        int left = 0;
        int right = nums.size()-1;
        int k = nums.size()-1;
        vector<int> result(nums.size(), 0);
        while(k >= 0){
            if(nums[left] * nums[left] > nums[right] * nums[right]){
                result[k] = nums[left] * nums[left];
                left++;
            }
            else{
                result[k] = nums[right] * nums[right];
                right--;
            }
            k--;
        }
        return result;
        
    }
};

同样也可以暴力排序，然后由双指针改进

暴力算法是最简单的思想，而双指针是暴力算法的改进，改进方向

长度最小的子数组

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

示例：

输入：s = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

class Solution {
public:
    int minSubArrayLen(int target, 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 (sum >= target) {
                subLength = j - i + 1; //当前滑动窗口长度；
                result = result < subLength ? result : subLength;
                sum -= nums[i++]; //滑动窗口左边界向右移动一个单位；
            }
        }
        return result == INT32_MAX ? 0 : result;
    }
};