【基础算法】——双指针算法

今天药忘吃喽~ 2024-04-27 07:35 36阅读 0赞

#### 文章目录 ####

*  一、算法原理
 *  二、算法实战
 *   *  1. 力扣283 移动零
     *  2. 力扣1089 复写零
     *  3. 力扣15 三数之和
     *  4. 力扣18 四数之和
 *  三、总结

--------------------

## 一、算法原理 ##

双指针算法是指在遍历对象的过程中不是普通的使用单个指针进行访问，而是使用两个相同方向(快慢指针)或者相反方向（对撞指针）的指针进行扫描，从而达到相应的目的。常见的双指针算法有两种：

*  `在一个序列里，用两个指针维护一段区间`
 *  `在两个序列里，一个指针指向一个序列，另外一个指针指向另外一个序列，来维护某种次序。`

? **算法模板**

for (int i = 0, j = 0; i < n; i ++ )  // j从某一位置开始，不一定是0
    {
        
        while (j < i && check(i, j)) j ++ ;
    
        // 具体问题的逻辑
    }
    常见问题分类：
        (1) 对于一个序列，用两个指针维护一段区间，比如快排的划分过程
        (2) 对于两个序列，维护某种次序，比如归并排序中合并两个有序序列的操作

--------------------

## 二、算法实战 ##

### 1. 力扣283 移动零 ###

> ![在这里插入图片描述][870369c9c6b44ad6ac0cc99df4d2a57b.png]  
> [题目链接][Link 1]

**算法原理：**

![在这里插入图片描述][4a3c0c3721d04c439677caef1b26ff8a.png]

**代码实现：**

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

--------------------

### 2. 力扣1089 复写零 ###

> ![在这里插入图片描述][58ebc2dfede4445f856e0f8df3515d3c.png]  
> [复写零][Link 2]

**算法原理：**

![在这里插入图片描述][077529e23bf34a34b3e21fede5cf24eb.png]

**代码实现：**

class Solution {
        
    public:
        void duplicateZeros(vector<int>& arr) {
        
            //从前向后遍历，寻找cur和dest的位置
            int dest = -1, cur = 0, n = arr.size();
            for(cur = 0; cur < n; cur++)
            {
        
                if(arr[cur] == 0)
                    dest+=2;
                else
                    dest++;
                if(dest >= n - 1)
                    break;
            }
            if(dest == n)
            {
        
                arr[n - 1] = 0;
                dest-=2, cur--;
            }
            while(cur >=0 && dest >= 0)
            {
        
                if(arr[cur] == 0)
                    arr[dest--] = 0;
                arr[dest--] = arr[cur];
                cur--;
            }
        }
    };

--------------------

### 3. 力扣15 三数之和 ###

> ![在这里插入图片描述][547cd2076f5d41a19061a43efb80c466.png]  
> [三数之和][Link 3]

**算法原理：**

本题我们采用 `“排序+双指针”` 的思想。先将数组排序，用一层循环来枚举第一个数，当我们确定第一个元素后，另外两个元素n2+n3之和就变成了一个定值。当n2增大时n3减小，当n2减小时n3增大。

这样我们就可以在确定第一个元素后，运用双指针来同时确定第二个和第三个元素的值。当然这里我们一定要注意去重的问题，在枚举的过程中就将去重的工作顺便做了即可。

**代码实现：**

class Solution {
        
    public:
        vector<vector<int>> threeSum(vector<int>& nums) {
        
            int n = nums.size();
            sort(nums.begin(), nums.end());
            vector<vector<int>> ret;
            if(nums[0] > 0 || nums[n - 1] < 0 || n < 3)
                return ret;
            if(nums[0] == 0 && nums[n - 1] == 0)
                return {
        {
        0,0,0}};
                
            //双指针算法
            for(int i = 0; i < n - 2; i++)
            {
        
            	//去重
                if(i && nums[i] == nums[i - 1])
                    continue;
                if(nums[i] > 0)
                    break;
                int left = i + 1, right = n - 1;
                while(left < right)
                {
        
                    int sum = nums[i] + nums[left] + nums[right];
                    
                    if(sum < 0)
                        left++;
                    else if(sum > 0)
                        right--;
                    else
                    {
        
                        ret.push_back({
        nums[i], nums[left], nums[right]});
                        left++,right--;
                        // 去重
                        while(left < right && nums[left] == nums[left - 1])
                            left++;
                        while(left < right && nums[right] == nums[right + 1])
                            right--;
                    }
                }
            }
            return ret;
        }
    };

### 4. 力扣18 四数之和 ###

> ![在这里插入图片描述][6d512aa3a6cd4f25a3e88d48b81c39b3.png]  
> [四数之和][Link 4]

**算法原理：**

四数之和可以在三数之和的基础上做一下修改，三数之和通过双指针解法可以将时间复杂度降到O(n2)，四数之和通过双指针的方法可以将时间复杂度降到 O(n3)。具体方法为：

*  外面双层循环，代表四个数中的前两个数。
 *  里面为一首一尾双指针，代表四个数中的后两个数，双指针逐步往中间移动，直至相遇。

**代码实现：**

class Solution {
        
    public:
        vector<vector<int>> fourSum(vector<int>& nums, int target) {
        
            int n = nums.size();
            sort(nums.begin(), nums.end());
            vector<vector<int>> ret;
    
            for(int i = 0; i < n - 3; i++)
            {
        
                if(i && nums[i] == nums[i - 1])
                    continue;
                for(int j = i + 1; j < n - 2; j++)
                {
        
                    if(nums[j] == nums[j - 1] && j != i + 1)
                        continue;
                    
                    long long sum = (long long)target - nums[i] - nums[j];
                    
                    int left = j + 1, right = n - 1;
                    while(left < right)
                    {
        
                        if(nums[left] + nums[right] < sum)
                            left++;
                        else if(nums[left] + nums[right] > sum)
                            right--;
                        else
                        {
        
                            ret.push_back({
        nums[i], nums[j], nums[left], nums[right]});
                            left++,right--;
                            while(left < right && nums[left] == nums[left - 1])
                                left++;
                            while(left < right && nums[right] == nums[right + 1])
                                right--;
                        }
                    }
                }
            }
            return ret;
        }
    };

## 三、总结 ##

双指针算法的用途非常的广泛，在数组和链表的操作中是非常常见的，当我们运用双指针时，需要找到目标对象的性质——单调性，当然也必须别忘了指针`i`和指针`j`的范围更新问题。最后，多刷题、多总结才能将其运用得当哦！

[870369c9c6b44ad6ac0cc99df4d2a57b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/fd65dc8bbe9f4b4d91b25b5430350ea4.png
[Link 1]: https://leetcode.cn/problems/move-zeroes/
[4a3c0c3721d04c439677caef1b26ff8a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/ff8c0e6bd2fd47e8bd3157d34f2819e1.png
[58ebc2dfede4445f856e0f8df3515d3c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/f5ae20a5957c40039e9d9a2a9c6fa549.png
[Link 2]: https://leetcode.cn/problems/duplicate-zeros/
[077529e23bf34a34b3e21fede5cf24eb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/1aef6109f5bf450693b3f818a6e80a1d.png
[547cd2076f5d41a19061a43efb80c466.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/e9c32c0245f64607bc232e2bee0241e9.png
[Link 3]: https://leetcode.cn/problems/3sum/
[6d512aa3a6cd4f25a3e88d48b81c39b3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/27/c9d8940fb1b54c69bd03d458d2b4dc77.png
[Link 4]: https://leetcode.cn/problems/4sum/