力扣-数组-双指针

题目顺序

27移除元素，26删除有序数组中的重复项，283移动零，844比较含退格的字符串，977有序数组的平方

解题思路

1.确定双指针，一个遍历数组，一个确定新数组元素

2.确定循环终止的条件一般是left<=right，具体根据实例判断

 

 

 

 

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        # 双指针法，left从前往后定位val，right从后往前把非val换到left指向的val位置
        left = 0
        right = len(nums)-1
        while(left<right):# 还没遍历完数组时进入循环
            if nums[left]==val:
                if nums[right]!=val:
                    nums[left] = nums[right]
                    left += 1
                    right -= 1
                else: 
                    right -= 1
            else: 
                left += 1
        # 判断跳出循环时，left和right的大小关系，返回left相关
        # left指向要保留
        if left==right and val!=nums[left]:
            return left+1
        # right<left或left==right，nums[left]==val，删除
        else:
            return left

 

 

 

 

 

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        left, p = 0, 0
        # 指针p指向新数组中确定的元素，指针left遍历整个数组；
        right = len(nums)-1
        while(left<=right):
        # 如果left指向与新数组的p相同时，继续遍历，定p动left
            if nums[p]==nums[left]:
                left += 1
            else:
        # 如果left指向与新数组的p不一致时，更新p+1所在，p++
                nums[p+1] = nums[left]
                p += 1
        return p+1

 

 

 

class Solution(object):
    def moveZeroes(self, nums):
        """
        :type nums: List[int]
        :rtype: None Do not return anything, modify nums in-place instead.
        """
        # 双指针法
        pos = 0
        left = 1
        right = len(nums)-1
        while(left<=right):
            if nums[pos]==0 and nums[left] != 0:
                nums[pos] = nums[left]
                nums[left] = 0
                pos += 1
                left += 1
            elif nums[pos]==0 and nums[left] == 0:
                left += 1
            elif nums[pos] != 0:
                pos += 1
                left += 1
        return pos

# 常规的双指针法解题，注意终止条件，if语句和返回值。

 

 

 

class Solution(object):
    def backspaceCompare(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        # 理解题目，要删除#和它之前相同个数的字符
        s = list(s)
        pos = 0
        left = 0
        right = len(s)-1
        while (left <= right):
            if pos<0:# 退格多于字符
                pos = 0
            if s[left]=='#':# 继续遍历
                pos -= 1
                left += 1
            else:# 删掉一个元素
                s[pos] = s[left]
                pos += 1
                left += 1
        ss = ''.join(s[:pos])

        t = list(t)
        pos = 0
        left = 0
        right = len(t)-1
        while (left <= right):
            if pos<0:
                pos = 0
            if t[left]!='#':
                t[pos] = t[left]
                pos += 1
                left += 1
            else:
                pos -= 1
                left += 1
        tt = ''.join(t[:pos])
        return ss==tt

        

# 对字符串s而言，left指针用来遍历整个字符串，pos指针用来获取新字符串的内容；

# 当left不指向'#'时，对pos赋值；指向'#'时，pos退格，left前进。

 

 

 

class Solution(object):
    def sortedSquares(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        # 双指针法，与直接排序的不同是，数组正负两端是有序的，所以可以一左一右一次比较
        i, j, pos = 0, len(nums)-1, len(nums)-1
        res = [0]*len(nums)
        while(i<=j):
            if nums[i]*nums[i]<nums[j]*nums[j]:
                res[pos] = nums[j]*nums[j]
                j -= 1
                pos -= 1
            else:
                res[pos] = nums[i]*nums[i]
                i += 1
                pos -= 1
        return res

# 因为原始数组正负两端是各自有序的，所以可以双指针，左右依次比较；

# 后续要用直接插入排序和快排做一下。