数组双指针

双指针

双指针是一种思想或一种技巧并不是特别具体的算法。
就是用两个变量动态存储两个结点，来方便我们进行一些操作，通常用在线性的数据结构中，这部分题目主要是针对列表中的双指针解法，在链表中的用法会在后面更新。

常见的双指针包括同速双指针和快慢双指针。
顾名思义，同速双指针就是两个指针的移动速度相同。快慢双指针就是两个指针变量的移动速度不同，一般情况是根据快指针的状态来更新慢指针的状态。

27. 移除元素

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

from typing import List


class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        first, second = 0, 0
        while second < len(nums):
            if nums[second] != val:
                nums[first] = nums[second]
                first += 1
            second += 1
        return first

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

给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。
由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么nums的前 k 个元素应该保存最终结果。
将最终结果插入nums 的前 k 个位置后返回 k 。
不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

from typing import List


class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        if len(nums) == 1:
            return 1
        first, second = 0, 0
        while second < len(nums):
            if nums[first] != nums[second]:
                first += 1
                nums[first] = nums[second]
            second += 1

        return first + 1

283. 移动零

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

from typing import List


class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        left, right = 0, 0
        while right < len(nums):
            if nums[right] != 0:
                nums[right], nums[left] = nums[left], nums[right]
                left += 1
            right += 1

844. 比较含退格的字符串

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

class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        first = len(s) - 1
        second = len(t) - 1
        fs ,ss = 0, 0
        while first >= 0 or second >= 0:
            while first >= 0:
                if s[first] == "#":
                    first -= 1
                    fs += 1
                elif fs > 0:
                    fs -= 1
                    first -= 1
                else:
                    break
            while second >= 0:
                if t[second] == "#":
                    second -= 1
                    ss += 1
                elif ss > 0:
                    ss -= 1
                    second -= 1
                else:
                    break
            
            if first >= 0 and second >= 0:
                if s[first] != t[second]:
                    return False
            elif first >= 0 or second >= 0:
                return False
            
            first -= 1
            second -= 1
        return True

977. 有序数组的平方

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

from typing import List


class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        ans = [0] * len(nums)
        first, last = 0, len(nums) - 1
        index = len(nums) - 1
        while index >= 0:
            if abs(nums[first]) >= abs(nums[last]):
                ans[index] = nums[first] * nums[first]
                first += 1
            else:
                ans[index] = nums[last] * nums[last]
                last -= 1
            index -= 1
        return ans