双指针算法

双指针

27. 移除元素

力扣链接

题面

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

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

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

例子

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

思路

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

定义快慢指针

• 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
• 慢指针：指向更新 新数组下标的位置

代码实现

function removeElement(nums: number[], val: number): number {
    let slow=0
    for(let fast=0,len=nums.length;fast<len;fast++){
        // 快指针走在前面，寻找不等于val的值
        if(nums[fast]!==val){
            // 慢指针在后面，指向新数组的下标
            nums[slow]=nums[fast]
            slow++
        }
    }
    return slow
};

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

力扣链接

代码实现

function removeDuplicates(nums: number[]): number {
    const n = nums.length;
    // 空数组返回0
    if (n === 0) {
        return 0;
    }
    // nums[0]肯定不会与前面的数重合，所以从1开始
    let fast = 1, slow = 1;
    while (fast < n) {
        // 快指针在前面寻找不重复的元素
        if (nums[fast] !== nums[fast - 1]) {
            // 慢指针指向新数组的下标
            nums[slow] = nums[fast];
            slow++;
        }
        fast++;
    }
    return slow;
};

283. 移动零

力扣链接

代码实现

function moveZeroes(nums: number[]): void {
    let n=nums.length
    let slow=0,fast=0
    // 用于标记是否移动过0
    let flag=false
    while(slow<n){
        // 相当于把0删掉
        if(nums[fast]!=0&&fast<n){
            nums[slow++]=nums[fast]
        }
        else flag=true
        fast++
        // 删掉后，接着新数组添加0
        if(fast>=n&&flag) nums[slow++]=0
    }
};

function moveZeroes(nums: number[]): void {
    // 右指针不断向右移动，每次右指针指向非零数，则将左右指针对应的数交换，同时左指针右移。
    let slow=0,fast=0
    while(fast<nums.length){
        if(nums[fast]){
            let tem=nums[fast]
            nums[fast]=nums[slow]
            nums[slow]=tem
            slow++
        }
        fast++
    }
};

977. 有序数组的平方

力扣链接

代码实现

function sortedSquares(nums: number[]): number[] {
    // 数组是非递减的，即左右两边的数的平方是比较大的值
    // 每次比较两边，将大值插入数组尾部
    let n=nums.length-1
    let res:number[]=new Array(n)
    for(let i=0,j=nums.length-1;i<=j;){
        if(nums[i]*nums[i]>nums[j]*nums[j]){
            res[n--]=nums[i]*nums[i]
            i++
        }
        else{
            res[n--]=nums[j]*nums[j]
            j--
        }
    }
    return res
};

844. 比较含退格的字符串

力扣链接

代码实现

function backspaceCompare(s: string, t: string): boolean {
    // 应为退格会将前面的字符删除，所以从后向前比较
   let i = s.length - 1,
        j = t.length - 1,
        skipS = 0,
        skipT = 0;
    // 大循环
    while(i >= 0 || j >= 0){
        // S串 循环
        while(i >= 0){
            if(s[i] === '#'){
                // 记录跳过的元素
                skipS++;
                i--;
            }else if(skipS > 0){
                // 跳过元素
                skipS--;
                i--;
            }else break;
        }
        // T串 循环
        while(j >= 0){
            if(t[j] === '#'){
                // 记录跳过的元素
                skipT++;
                j--;
            }else if(skipT > 0){
                // 跳过元素
                skipT--;
                j--;
            }else break;
        }
        if(s[i] !== t[j]) return false;
        i--;
        j--;
    }
    return true;
};