Leetcode 双指针法

---

介绍

双指针算法是一种通过设置两个指针不断进行单向移动来解决问题的算法。它包含两种形式：一是两个指针分别指向不同的序列。比如：归并排序的合并过程。二是两个指针指向同一个序列。比如：快速排序的划分过程。

题目

27. 移除元素

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。

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

26. 删除有序数组中的重复项

给你一个升序排列的数组 nums ，请你原地删除重复出现的元素，使每个元素只出现一次，返回删除后数组的新长度。元素的相对顺序应该保持 一致 。不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int left = 0;
        for (int right = 1; right < nums.size(); right++) {
            if (nums[right] != nums[left]) {
                left++;
                nums[left] = nums[right];
            }
        }
        return left+1;
    }
};

283.移动零

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

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int left = 0, right = 0;
        while (right < nums.size()) {
            if (nums[right] != 0) {
                nums[left] = nums[right];
                left++;
            }
            right++;
        }
        while (left < right) {
            nums[left] = 0;
            left++;
        }
        return;
    }
};

844. 比较含退格的字符串

给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int s_pointer = s.size() - 1, t_pointer = t.size() - 1, s_token = 0,  t_token = 0;
        while (s_pointer > -1 || t_pointer > -1) {
            while (s_pointer > -1) {
                if (s[s_pointer] == '#') {
                    s_token++;
                    s_pointer--;
                } else if (s_token > 0) {
                    s_token--;
                    s_pointer--;
                } else {
                    break;
                }
            }
            while (t_pointer > -1) {
                if (t[t_pointer] == '#') {
                    t_token++;
                    t_pointer--;
                } else if (t_token > 0) {
                    t_token--;
                    t_pointer--;
                } else {
                   break; 
                }
            }
            if (s_pointer >-1 && t_pointer >-1) {
                if (s[s_pointer] != t[t_pointer]) return 0;
            } else {
               if (s_pointer >-1 || t_pointer >-1) return 0; 
            }
            s_pointer--;
            t_pointer--;
        }
        return 1;
    }
};

这个题目使用“栈”是更好的选择，但仍可采用第二种形式的双指针，两个指针分别指向两个序列，但难度会有一定的提升。

977.有序数组的平方

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

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int left = 0 ,n = nums.size(), right = n-1;
        vector<int> ans (n, 0); 
        n = n -1 ;
        while (left <= right) {
            if (abs(nums[left]) > abs(nums[right])) {
                ans[n] = nums[left] * nums[left];
                left++;
                n--;
            }else {
                ans[n] = nums[right] * nums[right];
                right--;
                n--;
            }
        }
        return ans;
    }
};

从序列的两端找剩余元素中绝对值最大的元素。

https://leetcode.cn/