leetcode刷题 day2 | 数组：移除元素

知识点：

---

python 比较字符串可以用“==” is

题目：

---

27.移除元素

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

**发现for循环里面的i值改变并不影响循坏执行次数，用不了双重for循环？？

for i in range(0,len(nums)):
	i=i+1

解法①：
慢指针指向数组中val的位置，快指针指向第一个非val位置，交换位置，l++，r++

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        if nums is None or len(nums)==0: 
            return 0 
        l,r=0,0
        while r<len(nums): 
            if nums[r]!=val:
                nums[l]=nums[r]
                l=l+1
            r=r+1
        return l

解法②：
慢指针从左往右，指向val的位置上，快指针从右往左，指向不是val的位置，交换两个指针上的值

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        if nums is None or len(nums)==0: 
            return 0 
        l,r=0,len(nums)-1
        while l<r:
            while(l<r and nums[l]!=val):
                l=l+1
            while(l<r and nums[r]==val):
                r=r-1
            nums[l],nums[r]=nums[r],nums[l]

        if nums[l]==val:
            return l
        else:
            return l+1 

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

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

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        left,right=0,0
        if not nums:
            return 0
        while(right<len(nums)):
            if nums[right]!=nums[left]:
                left=left+1 #找到替换位置
                nums[left]=nums[right]
            else:
                right=right+1
        return left+1

283.移动零

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

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

844.比较含退格的字符串

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

解法①：
1.利用栈的思想，如果遇到“#”且栈非空，则从栈中弹出字符，否则将字符压入栈
2.利用“==”，比较去掉“#”的两个字符串是否相等

class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        def build(s:str):
            a=list()
            for ch in s:
                if ch!="#":
                    a.append(ch)
                elif a:
                    a.pop()
            return "".join(a)
        return build(s)==build(t)

解法②：
从后往前遍历字符串，所遇情况有三，如下所示：

1. 若当前字符是 #，则 skipS 自增 1，i–；
2. 若当前字符不是 #，且 skipS 不为 0，则 skipS 自减 1，i–；
3. 若当前字符不是 #，且 skipS 为 0，则代表当前字符不会被消除，我们可以用来和 T 中的当前字符作比较。

因为有“##”的情况出现，所以得记录“#”个数，而不是直接遇“#”退两格。

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