Python刷力扣-数组专题-快慢指针

Python刷力扣-数组专题-快慢指针

27. 移除元素

题目链接27.移除元素

思路1：暴力法，双重循环

代码：

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        i = 0
        n = len(nums)
        while i<n:
            if nums[i] == val:
                for j in range(i,n-1):
                    nums[j]=nums[j+1]
                n-=1
                #这的i-=1是比如有2，2连着的情况，回溯一个i，此处应该手动模拟一下
                i-=1
            i+=1
        return n

思路2：双指针法

代码：

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

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

题目链接26. 删除有序数组中的重复项

思路：双指针

代码：

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

283. 移动零

思路1：两次遍历，先把前几项用不为0的数覆盖，再将后几项改为0

代码：

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        size = len(nums)
        j = 0
        for i in range(size):
            if nums[i]!=0:
                nums[j] = nums[i]
                j += 1
        for i in range(j,size):
            nums[i] = 0

思路2：一次遍历

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        j = 0
        for i in range(len(nums)):
            if nums[i]:
                nums[j],nums[i] = nums[i],nums[j]
                j+=1

844. 比较含退格的字符串

思路1：字符串转List，在原List上操作，判断字符是否是#

代码

class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        list_s,list_t = list(s),list(t)
        idx_a = 0
        for i in range(len(list_s)):
            if list_s[i] != '#':
                list_s[idx_a] = list_s[i]
                idx_a += 1
            else:
                idx_a -=1 if idx_a>0 else 0
        idx_b = 0
        for i in range(len(list_t)):
            if list_t[i]!='#':
                list_t[idx_b] = list_t[i]
                idx_b += 1
            else:
                idx_b -=1 if idx_b>0 else 0
        return list_s[:idx_a] == list_t[:idx_b]

思路2：栈解法

代码：

class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        stack1 = []
        stack2 = []
        for i in s:
            if i == '#' and stack1:
                stack1.pop()
            elif i!='#':
                stack1.append(i)
        
        for i in t:
            if i =='#' and stack2:
                stack2.pop()
            elif i!='#':
                stack2.append(i)
        return stack1 == stack2

977. 有序数组的平方

题目链接977. 有序数组的平方

思路1：暴力解法，平方后排序

代码：

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        size = len(nums)
        for i in range(size):
            nums[i]=nums[i]**2
        nums.sort()
        return nums

思路2：双指针法

数组 nums 是非递减排序的数组，那就相当于是个递增的数组，且每个元素的取值 -10^4 <= nums[i] <= 10^4，这就证明元素值有正有负。
通过这两个条件其实我们可以得出，平方以后的最大值肯定出现在两侧，不是左边就是右边（负数的平方为正数）。
碰到这种情况，我们一般祭出双指针法来解决，left 指向下标 0，right 指向下标 n - 1：
新建一个结果数组 res 存储最后的结果，site 指向数组末尾，数组从后向前存储。
若 nums[left] * nums[left] < nums[right] * nums[right]，res[site] = nums[right] * nums[right]。
若 nums[left] * nums[left] >= nums[right] * nums[right]，res[site] = nums[left] * nums[left]。

代码：

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        if len(nums) == 1:
            return [nums[0]*nums[0]]
        #初始化双指针
        left = 0
        right = len(nums)-1
        #存储结果数组，从数组末尾开始存储
        res = [-1]*len(nums)
        site = len(nums)-1
        #注意这里是<=
        while left<=right:
            #从两端遍历，将平方数组大的存储在res数组中
            if nums[left]*nums[left]<nums[right]*nums[right]:
                res[site] = nums[right]*nums[right]
                right-=1
            else:
                res[site] = nums[left]*nums[left]
                left+=1
            site-=1
        return res