双指针法的运用

27. 移除元素

题目介绍：

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。然后返回 nums 中与 val 不同的元素的数量。
假设 nums 中不等于 val 的元素数量为 k，要通过此题，您需要执行以下操作：
1、更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。
2、返回 k。

示例 1:

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2,_,_]
解释：你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

示例 2:

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3,_,_,_]
解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。
注意这五个元素可以任意顺序返回。
你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。

提示：
0 <= nums.length <= 100
0 <= nums[i] <= 50
0 <= val <= 100

思路：

可以使用双指针方法解决，设置快慢指针，快指针先于慢指针移动，当快指针指向的元素值不是所需删除的元素val时，慢指针记录下此时的值并后移一位，最后需要返回的不等于val的元素个数即是慢指针slow的值。
具体代码如下：

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        //快慢指针
        int slow = 0  ;
        for( int fast = 0 ; fast < nums.size() ; fast++ ){
            if(  nums[fast] != val ){
                //当此元素不是需要删除的元素 ，nums[slow]记录此时的值，slow后移一位
                nums[slow++] = nums[fast] ; 
            }
        }
        return slow ; 
    }
};

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

题目介绍：

给你一个 非严格递增排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。
考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：
1、 更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
2、返回 k 。

示例 1:

输入：nums = [1,1,2]
输出：2, nums = [1,2,_]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例 2:

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

提示：
1 <= nums.length <= 3 * 104
-104 <= nums[i] <= 104
nums 已按 非严格递增 排列

思路：

通过双指针方法解决，设置快慢指针，慢指针slow从0开始，快指针fast从1开始，当fast指向的值不等于slow指向的值的时候，slow先后移一位，再将fast指向的值赋给slow，最后返回的唯一元素的数量 k就是slow+1 。
具体代码如下：

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int slow = 0 ;
        //快指针应从1开始
        for(int fast = 1 ; fast < nums.size() ; fast++ ){
            if( nums[fast] != nums[slow])   
                nums[++slow] = nums[fast] ; //当快指针目前所指的元素值不等于慢指针所指的值时，慢指针先+1，再用慢指针记录下快指针的值
        }   
        return slow +1 ; //最后返回的元素个数为慢指针的值+1
    }
};

283. 移动零

题目介绍：

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。

示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

示例 2:

输入: nums = [0]
输出: [0]

提示：
1 <= nums.length <= 104
-2^31 <= nums[i] <= 2^31 - 1

思路：

设置快慢指针，快慢指针都从0出发，当fast指向的值不等于0的时候，将快指针的值赋给慢指针，慢指针后移一位，最后再进行遍历，将下标大于等于slow的元素全部改为0 。
具体代码如下：

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int slow = 0 ;
        for(int fast = 0 ;fast <nums.size() ; fast++ ){
            if( nums[fast] != 0 ){
                nums[slow++ ] = nums[fast] ; 
            }
        }
        //将下标大于等于slow的元素全部改为0
        for( int i = slow ; i < nums.size() ; i++ ){
            nums[i] =0 ;
        }
    }
};

844. 比较含退格的字符串

题目介绍：

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

示例 1:

输入：s = "ab#c", t = "ad#c"
输出：true
解释：s 和 t 都会变成 "ac"。

示例 2:

输入：s = "ab##", t = "c#d#"
输出：true
解释：s 和 t 都会变成 ""。

示例 3:

输入：s = "a#c", t = "b"
输出：false
解释：s 会变成 "c"，但 t 仍然是 "b"。

提示：
1 <= s.length, t.length <= 200
s 和 t 只含有小写字母以及字符 ‘#’

思路：

先通过双指针获取字符串s以及字符串t的有效长度以及最后的有效内容，再判断两个字符串是否相同。
具体代码如下：

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int slow_s = 0 , slow_t =0 ;

        //循环遍历字符串s，获取推格后的字符串长度以及内容
        for(int i =0 ; i < s.size() ; i++ ){
            if( s[i] == '#'){
                if(slow_s != 0 )  --slow_s ;  //当此时元素为#，但有效长度slow_s不为0时，slow_s减一
            }else{
                s[slow_s++] = s[i] ; //当元素不为#时，记录下此时的元素内容，有效长度slow_s加一
            }
        }
        //循环遍历字符串t，获取推格后的字符串长度以及内容
        for(int i =0 ; i < t.size() ; i++ ){
            if( t[i] == '#'){
                if(slow_t != 0 )    --slow_t ;  //当此时元素为#，但有效长度slow_t不为0时，slow_t减一
            }else{
                t[slow_t++] = t[i] ; //当元素不为#时，记录下此时的元素内容，有效长度slow_t加一
            }
        }

        if( slow_s != slow_t)   return false ;  //两个字符串最后的有限内容长度不等时，直接返回false
        //循环判断两个字符串的有效内容是否相同
        for( int i =0 ; i < slow_s ; i++ ){
            if( s[i] != t[i] )  return false ;   //当出现不同元素时直接返回false 
        }
        return true ;

    }
};

977. 有序数组的平方

题目介绍：

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

示例 1:

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

示例 2:

输入：nums = [-7,-3,2,3,11]
输出：[4,9,9,49,121]

提示：
1 <= nums.length <= 104
-104 <= nums[i] <= 104
nums 已按 非递减顺序 排序

思路：

因为提供的已经是一个有序数组，故将各个元素平方后的最大值一定是在数组的两端出现，所以可以使用双指针对其比较，left指针从0开始，right指针从nums.size()-1开始，将两者指向的元素的值的平方进行比较，将较大的值填入result[max]中，然后max-1 。
具体代码如下：

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int max = nums.size() -1 ;  
        vector<int> result( nums.size() , 0) ; //创建一个新的vector,长度与nums相同且值都为0
        //从两端开始遍历比较
        for( int left = 0 , right = nums.size()-1 ; left <= right ; ){
            if( nums[left] * nums[left] > nums[right] * nums[right] )
            {
                //若左边的平方大于右边的平方，将左边平方的值赋值给result[max] ,max减一，left向右移一位
                result[max--] = nums[left] *nums[left]; 
                ++left ; 
            }else{
                //若右边的平方大于左边的平方，将右边平方的值赋值给result[max] ,max减一，right向左移一位
                result[max--] = nums[right] * nums[right];
                --right ;
            }
        }
        return result ;
    }
};