2025/1/2 【双指针法】LeetCode27.移除元素 【√】

27. 移除元素 - 力扣（LeetCode）

代码随想录

数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。

My answer：快慢指针法

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        n = len(nums)
        j = 0
        for i in range(n):
            if nums[i] != val:
                nums[j] = nums[i]
                j += 1
        return j

i是快指针（fast），j是慢指针（slow）

解法2：暴力解法

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        n = len(nums)
        i = 0
        while i < n:
            if nums[i] == val:
                for j in range(i+1, n): #发现需要移除的元素，就将数组集体向前移动一位
                    nums[j-1] = nums[j]
                i -= 1 #注意：因为下标i以后的数值都向前移动了一位，所以i也向前移动一位
                n -= 1 
            i += 1 
        return n 

解法3：相向双指针法

 

 相关题目推荐：

26. 删除有序数组中的重复项 - 力扣（LeetCode）  【√】

283. 移动零 - 力扣（LeetCode）                             【√】

844. 比较含退格的字符串 - 力扣（LeetCode）     🌺🌺

方法1：利用栈（列表）模拟字符串退格的效果

class Solution:
    def endStr(self, s):
        #得到字符串去掉退格字符的最终形态
        stack = []
        for char in s:
            if char == '#':
                if stack:
                    stack.pop()
            else:
                stack.append(char)
        return ''.join(stack)


    def backspaceCompare(self, s: str, t: str) -> bool:
        return self.endStr(s) == self.endStr(t)     

快慢双指针方法：

class Solution: 
    def helper(self, s):
        s_list = list(s)
        slow = fast = 0
        while fast < len(s_list):
            if s_list[fast] != '#':
                s_list[slow] = s_list[fast]
                slow += 1
            else:
                if slow > 0:
                    slow -= 1
            fast += 1
        return ''.join(s_list[:slow])

    def backspaceCompare(self, s: str, t: str) -> bool:
        return self.helper(s) == self.helper(t)

977. 有序数组的平方 - 力扣（LeetCode）  【√】

方法一：直接排序

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        return sorted(num*num for num in nums)

双指针也可以，参见LeetCode官方题解，但是感觉没有必要。因为空间复杂度是O（n），而且条件判断比较复杂。