双指针法_27； 26； 283； 844； 977__leetcode_python

27 移除元素

# 27.移除元素

# # 暴力求解
# class Solution(object):
#     def removeElement(self, nums:list[int], val:int):
#
#         if not nums:
#             return 0
#         lens = 0
#         for i in range(0, len(nums)):
#             if nums[i] != val:  # 逐一扫描，只有不等于val的值才能进入新的数组
#                 nums[lens] = nums[i]
#                 lens += 1
#
#         return lens

# # pop
# class Solution(object):
#     def removeElement(self, nums, val):
#         l = len(nums)
#         for i in range(l - 1, -1, -1):  # 从l-1到-1，倒着走
#             if nums[i] == val:
#                 nums.pop(i)
#         return len(nums)

# # 快慢指针
# class Solution:
#     def removeElement(cls, nums: list[int], val: int) -> int:
#
#         fast = slow = 0
#
#         while fast < len(nums):
#
#             if nums[fast] != val:
#                 nums[slow] = nums[fast]
#                 slow += 1
#
#             # 当 fast 指针遇到要删除的元素时停止赋值
#             # slow 指针停止移动, fast 指针继续前进
#             fast += 1
#
#         return slow




# 快慢指针1.0
class Solution:
    def removeElement(cls, nums: list[int], val: int) -> int:

        fast = slow = 0
        while fast < len(nums):  # 易错：因为fast从0开始的，所以不用=
            if nums[fast] !=  val:
                nums[slow] = nums[fast]
                slow += 1
            fast += 1 # 为什么这一行不对齐上一行？因为fast不管是否nums[fast] !=  val，都要加一
        return slow






# # 测试 快慢指针1.0
# def removeElement(nums: list[int], val: int) -> int:
#
#         fast = slow = 0
#         while fast < len(nums):  # 易错：因为fast从0开始的，所以不用=
#             if nums[fast] !=  val:
#                 nums[slow] = nums[fast]
#                 slow += 1
#             fast += 1 # 为什么这一行不对齐上一行？
#         return slow
#
# print(removeElement([3,2,2,3],3))

26 删除排序数组中的重复项28

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

class Solution:
    def removeDuplicates(self, nums: list[int]) -> int:
        fast = slow = 1 # 反正第一个值肯定要使用的，直接从第二个值开始
        if not nums:  # 出错点：要考虑数组为零的情况
            return 0
        while fast < len(nums):  # 出错点：nums[fast] < len(nums)
            if nums[fast] != nums[fast - 1]:  # 判断条件是不等于上一个值，就可以进入新的数组
                nums[slow] = nums[fast]
                slow += 1
            fast += 1
        return slow

283 移动零

# 283.移动零
# 快慢指针
class Solution:
    def moveZeroes(self, nums: list[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        slow = fast = 0
        # if nums == 0
        #     return 0
        while fast < len(nums):
            if nums[fast] != 0:
                nums[slow] = nums[fast]
                slow += 1  # 最后一步完成num[slow]的排序，并+1
            fast += 1

        for i in range(slow, len(nums)):  # 在slow到最终数组长度的区间上将数字都变为0，之所以不需要len(nums)-1 是因为range本身也不包括右极限的值
            nums[i] = 0  # 同时也可以处理[0]数组

844 比较含退格的字符串

未完成

977 有序数组的平方

# 977.有序数组的平方
# 快慢指针法并不在乎是否是有序数组

# 先平方后排序，但是浪费了有序数组的优势
# class Solution:
#     def sortedSquares(self, nums: list[int]) -> list[int]:
#         slow = fast = 0
#         while fast < len(nums):
#             nums[slow] = nums[fast] * nums[fast]
#             slow += 1
#         fast += 1
#
#         nums.sort(reverse=False)
#
#         return nums

# # 测试
# def sortedSquares(nums: list[int]) -> list[int]:
#         slow = fast = 0
#         while fast < len(nums):
#             nums[slow] = nums[fast] * nums[fast]
#             slow += 1
#             fast += 1
#
#         nums.sorted(reverse = False)
#
#         return nums
#
# print(sortedSquares([-4,-1,0,3,10]))


# # 使用两个指针分别指向位置 00 和 n-1n−1，每次比较两个指针对应的数，选择较大的那个逆序放入答案并移动指针。
# class Solution:
#     def sortedSquares(self, nums: List[int]) -> List[int]:
#         n = len(nums)
#         ans = [0] * n
#
#         i, j, pos = 0, n - 1, n - 1
#         while i <= j:
#             if nums[i] * nums[i] > nums[j] * nums[j]:
#                 ans[pos] = nums[i] * nums[i]
#                 i += 1
#             else:
#                 ans[pos] = nums[j] * nums[j]
#                 j -= 1
#             pos -= 1
#
#         return ans

# # 测试
# def sortedSquares(nums: list[int]) -> list[int]:
#     n = len(nums)
#     ans = [0] * n
#
#     i, j, pos = 0, n - 1, n - 1
#     while i <= j:
#         if nums[i] * nums[i] > nums[j] * nums[j]:
#             ans[pos] = nums[i] * nums[i]
#             i += 1
#         else:
#             ans[pos] = nums[j] * nums[j]
#             j -= 1
#         pos -= 1
#
#     return ans
# print(sortedSquares([-4,-1,0,3,10]))


# # 1.0 左右指针
# class Solution:
#     def sortedSquares(self, nums: list[int]) -> list[int]:
#         # 设置一个存放答案的空数组
#         ans = [0] * len(nums)
#         # 设置左右指针，以及ans数组的指针
#         left, right, pos = 0, len(nums)-1, len(nums)-1  # 从后往前
#         while left <= right:
#             if nums[left] * nums[left] > nums[right] * nums[right]:  # 等于的情况下，移动left或者right都可以的，此处也可以加上=
#                 ans[pos] = nums[left] * nums[left]
#                 left = left + 1  # 执行一次赋值过程，就把指针调整一次
#             else:
#                 ans[pos] = nums[right] * nums[right]
#                 right = right - 1  # 执行一次赋值过程，就把指针调整一次
#             pos = pos - 1  # 易错点：千万记得要把ans的指针往前调整一位数
#
#         return ans

# 测试1.0
def sortedSquares(nums: list[int]) -> list[int]:
        # 设置一个存放答案的空数组
        ans = [0] * len(nums)
        # 设置左右指针，以及ans数组的指针
        left, right, pos = 0, len(nums)-1, len(nums)-1  # 从后往前
        while left <= right:
            if nums[left] * nums[left] > nums[right] * nums[right]:
                ans[pos] = nums[left] * nums[left]
                left = left + 1  # 执行一次赋值过程，就把指针调整一次
            else:
                ans[pos] = nums[right] * nums[right]
                right = right - 1  # 执行一次赋值过程，就把指针调整一次
            pos = pos - 1  # 易错点：千万记得要把ans的指针往前调整一位数

        return ans
print(sortedSquares([-10,-1,0,3,10]))