Leetcode TwoPointer知识点总结

• 344. Reverse String：字符串转置，Easy
  

  定义头尾指针，调换对应的字符

class Solution(object):
    def reverseString(self, s):
        """
        :type s: str
        :rtype: str
        """
        s = list(s)
        start = 0
        end = len(s)-1
        while(start<end):
            s[start],s[end] = s[end],s[start]
            start+=1
            end-=1
        return ''.join(s)

• 26. Remove Duplicates from Sorted Array：删除排序数组中的重复数字，返回剩余数组的长度，Easy

class Solution(object):
    def removeDuplicates(self, nums):
        if nums == []: return 0
        j = 1
        for i in range(1,len(nums)):
            if nums[i]!=nums[i-1]:
                nums[j] = nums[i]
                j+=1
        return j

• 27. Remove Element：删除数组中指定的数字，返回剩余数组的长度，Easy

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

• 283. Move Zeroes：将数组中的0移到最后，Easy
  

  用j表示当前可填充的位置

class Solution(object):
    def moveZeroes(self, nums):
        j=0
        for i in range(len(nums)):
            if nums[i]!=0:
                nums[j]=nums[i]
                j=j+1
        for i in range(j,len(nums)):
            nums[i]=0

• 167. Two Sum II - Input array is sorted：输入数组有序，返回和等于target的两个数的下标
  

  二分查找

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        for i in range(len(nums)):
            tmp=target-nums[i]
            start=i+1
            end=len(nums)-1
            while(start<=end):
                if tmp==nums[end]:
                    return [i+1,end+1]
                if tmp==nums[start]:
                    return [i+1,start+1]
                mid = (end - start) / 2+start
                if mid==start or mid==end:
                    break
                if tmp > nums[mid]:
                    start=mid
                elif tmp< nums[mid]:
                    end=mid
                else:
                    return [i+1,mid+1]

• 345. Reverse Vowels of a String：逆转字符串中的元音字母，Easy

class Solution(object):
    def reverseVowels(self,s):
        dic=['a','o','e','i','u','A','O','E','I','U']
        tmp=list(s)
        start,end = 0,len(tmp)-1
        while(start<end):
            while(start<end and tmp[start] not in dic):
                start+=1
            while(end>start and tmp[end] not in dic):
                end-=1
            if start<end:
                tmp[start],tmp[end] = tmp[end],tmp[start]
                start+=1
                end-=1
        return ''.join(tmp)

• 
  
• 763. Partition Labels：分割字符串，使得每个字母只会在一个子字符串中出现一次，Medium
  

Greedy
用字典存储字符第一次出现的位置，遍历字符串，如果当前字符已经出现过，则意味着要合并到第一次出现的字符所在的区间中

class Solution(object):
    def partitionLabels(self, S):
        """
        :type S: str
        :rtype: List[int]
        """
        stack = []
        maps = dict()
        for i,s in enumerate(S):
            if s not in maps:
                maps[s] = i
                stack.append([i,i])
            else:
                idx = maps[s]
                while(stack):
                    [start,end] = stack.pop()
                    if idx>=start:
                        break
                stack.append([start,i])
        ret = []
        for i in stack:
            ret.append(i[1]-i[0]+1)
        return ret

• 524. Longest Word in Dictionary through Deleting：给定字符串s和列表d,判断s删去一部分字符是否可以组成d中的字符串，如果可以求长度最长且字典序最小的字符串。否则返回空串。Medium

class Solution(object):
    def findLongestWord(self, s, d):
        """
        :type s: str
        :type d: List[str]
        :rtype: str
        """
        maxlen = [len(token) for token in d]
        pos = [0 for token in d]
        ret = []
        for token in s:
            for i in range(len(pos)):
                if pos[i]<maxlen[i] and d[i][pos[i]]==token:
                    pos[i]+=1
                    if pos[i] == maxlen[i]:
                        ret.append(d[i])
        if ret == []: return ''
        maxl = len(max(ret, key = len))
        return min(w for w in ret if len(w) == maxl)