双指针技巧秒杀七道数组题目

双指针技巧秒杀七道数组题目

在处理数组和链表相关问题时，双指针技巧是经常用到的，双指针技巧主要分为两类：左右指针和快慢指针。

所谓左右指针，就是两个指针相向而行或者相背而行；而所谓快慢指针，就是两个指针同向而行，一快一慢。

一、快慢指针技巧

数组问题中比较常见且难度不高的的快慢指针技巧，是让你原地修改数组。

力扣第 26 题「 删除有序数组中的重复项」

我的C++代码：

让慢指针 slow 走在后面，快指针 fast 走在前面探路，找到一个不重复的元素就赋值给 slow 并让 slow 前进一步。

这样，就保证了 nums[0..slow] 都是无重复的元素，当 fast 指针遍历完整个数组 nums 后，nums[0..slow] 就是整个数组去重之后的结果。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int slow=0,fast=1;
        while(fast<nums.size()){
            if(nums[fast]!=nums[slow]){
                slow++;
                nums[slow]=nums[fast];
            }
            fast++;
        }
        return slow+1;
    }
};

算法执行的过程如下 GIF 图：

力扣第 83 题「 删除排序链表中的重复元素」

与上题思路相同，或许更简单些？

class Solution {
public:
    ListNode* deleteDuplicates(ListNode* head) {
        if(head==nullptr)return nullptr;
        ListNode* slow=head;
        ListNode* fast=head;
        while(fast!=nullptr){
            if(fast->val!=slow->val)
            {
                slow->next=fast;
                slow=fast;
            }
            fast=fast->next;
        }
        slow->next=fast;
        return head;
    }
};

算法执行的过程请看下面这个 GIF：

力扣第 27 题「 移除元素」

我的C++代码

如果 fast 遇到值为 val 的元素，则直接跳过，否则就赋值给 slow 指针，并让 slow 前进一步。

注意这里和有序数组去重的解法有一个细节差异，我们这里是先给 nums[slow] 赋值然后再给 slow++，这样可以保证 nums[0..slow-1] 是不包含值为 val 的元素的，最后的结果数组长度就是 slow。

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

           }
            
            fast++;
        }
        return slow;
    }
};

力扣第 283 题「 移动零」

我的C++代码：

相当于移除 nums 中的所有 0，然后再把后面的元素都赋值为 0 即可。

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

二、左右指针的常用算法

1、二分查找

框架

int binarySearch(int[] nums, int target) {
    // 一左一右两个指针相向而行
    int left = 0, right = nums.length - 1;
    while(left <= right) {
        int mid = (right + left) / 2;
        if(nums[mid] == target)
            return mid; 
        else if (nums[mid] < target)
            left = mid + 1; 
        else if (nums[mid] > target)
            right = mid - 1;
    }
    return -1;
}

2、两数之和

力扣第 167 题「 两数之和 II」

C++代码：

只要数组有序，就应该想到双指针技巧。这道题的解法有点类似二分查找，通过调节 left 和 right 就可以调整 sum 的大小：

class Solution {
public:
    vector<int> twoSum(vector<int>& numbers, int target) {
        //左右双指针 大了就调整右指针 小了就调整左指针
        int le=0,ri=numbers.size()-1;
        while(le<ri){
            if(numbers[le]+numbers[ri]==target){
                return {le+1,ri+1};
            }
            //和小了
            if(numbers[le]+numbers[ri]<target){
                le++;
            }else{//和大了
                ri--;
            }
        }
        return {le+1,ri+1};
    }
};

3、反转数组

一般编程语言都会提供 reverse 函数，其实这个函数的原理非常简单，力扣第 344 题「 反转字符串」就是类似的需求，让你反转一个 char[] 类型的字符数组

void reverseString(char[] s) {
    // 一左一右两个指针相向而行
    int left = 0, right = s.length - 1;
    while (left < right) {
        // 交换 s[left] 和 s[right]
        char temp = s[left];
        s[left] = s[right];
        s[right] = temp;
        left++;
        right--;
    }
}

4、回文串判断

首先明确一下，回文串就是正着读和反着读都一样的字符串。

比如说字符串 aba 和 abba 都是回文串，因为它们对称，反过来还是和本身一样；反之，字符串 abac 就不是回文串。也是两个指针相向而行即可

力扣第 5 题「 最长回文子串」：

C++代码：

最长回文子串使用的左右指针和之前题目的左右指针有一些不同：之前的左右指针都是从两端向中间相向而行，而回文子串问题则是让左右指针从中心向两端扩展。

class Solution {
public:
    string longestPalindrome(string s) {
        int sz=s.size();
        string res="";
        for(int i=0;i<sz;i++){
            string a1=Palindrome(s,i,i);
            string a2=Palindrome(s,i,i+1);
            res=res.size()>a1.size()?res:a1;
            res=res.size()>a2.size()?res:a2;
        }
        return res;
    }
    string Palindrome(string s,int le,int ri){
        // 防止索引越界
        while (le >= 0 && ri < s.size()&& s[le] == s[ri]) {
        // 双指针，向两边展开
             le--; ri++;
        }
        // 返回以 s[l] 和 s[r] 为中心的最长回文串
        return s.substr(le+1,ri-le-1);
    }
};