class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        # print(f"nums_before = {nums}")
        if nums is None or len(nums)==0: 
            return 0 
        l=0
        r=len(nums)-1
        # print(f"r = {r}")
        while l<r: 
            while(l<r and nums[l]!=val):
                l+=1
                # print(f"l = {l}")
            while(l<r and nums[r]==val):
                r-=1
                # print(f"r = {r}")
            nums[l], nums[r] = nums[r], nums[l]  # 原地交换
            # print(f"nums[l] = {nums[l]}")
            # print(f"nums[r] = {nums[r]}")
            #print(f"nums_after = {nums}")
        if nums[l]==val: 
            return l 
        else: 
            return l+1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

int removeElement(int* nums, int numsSize, int val){
    int slow = 0;

    for (int fast=0; fast

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

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

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

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        slow = 0
        fast = 1
        while fast<len(nums):
            if nums[fast] != nums[slow]:
                slow += 1
                nums[slow] = nums[fast]
            fast += 1
        return slow+1
1
2
3
4
5
6
7
8
9
10

283. 简单移动零

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

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        slow = 0
        fast = 1
        while fast<len(nums):
            if nums[slow] == 0:
                if nums[fast] != 0:
                    nums[slow], nums[fast] = nums[fast], nums[slow]
                    slow += 1
                    fast += 1
                else:
                    fast += 1
            else:
                slow += 1
                fast += 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

844. 比较含退格的字符串

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

双指针法：

class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        i = len(s) - 1
        j = len(t) - 1
        SKIPS = 0
        SKIPT = 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 -= 1
            j -= 1
        return True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

977. 简单有序数组的平方

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

双指针法：

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        k = len(nums) - 1
        result = [-1] * len(nums)
        i = 0
        j = len(nums) - 1
        while i<=j :
            if nums[i] * nums[i] < nums[j] * nums[j]:
                result[k] = nums[j] * nums[j]
                k -= 1
                j -= 1
            else:
                result[k] = nums[i] * nums[i]
                k -= 1
                i += 1
        return result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:

        n = len(nums)
        i = 0
        j = n - 1
        k = n - 1
        result = [-1] * n

        while i <= j:
            lm = nums[i] * nums [i]
            rm = nums[j] * nums[j]

            if lm < rm:
                result[k] = rm
                j -= 1
            else:
                result[k] = lm
                i += 1
            k -= 1
        return result 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

注：
Q：如何生成和已给数组长度相同的数组，并将其初始化为-1？
A：[-1] * len(nums)