LeetCode算法刷题——数组篇

（一）. 双指针（快慢指针）

1 .简单篇
1.1 给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

   def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        # n-新数组长度；p-新数组指针，指向新数组最后一个元素；q-旧数组遍历指针
        n, p = 1, 0
        for q in range(len(nums)):
            if not nums[p] == nums[q]:
                p += 1
                nums[p] = nums[q]
                n += 1
        return n

1.2 给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。(已解,未能做到真正的因地制宜)

    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        #这里按照第一个例子进行解决，p,n只用一个即可，官方写法
        #p = 0
        p,n = 0,0
        for q in range(len(nums)):
            if not nums[q] == val:
                nums[p] = nums[q]
                #删除下面这行
                n += 1
                p = p+1
         #返回 p
        return n

1.3 给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素.(未解，思路为双指针逆) （可以将数组合并，然后排序nums1[:] = sorted(nums1[:m] + nums2)）

#########双指针（正向）
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: None Do not return anything, modify nums1 in-place instead.
        """
        # nums1[:] = sorted(nums1[:m] + nums2)
        nums1_copy = nums1[:m]
        nums1[:] =[]

        p1 = 0
        p2 = 0 
        
        while p1<m and p2<n:
            if nums1_copy[p1] < nums2[p2]:
                nums1.append(nums1_copy[p1]) 
                p1 = p1 +1
            else:
                nums1.append(nums2[p2])  
                p2 = p2 +1
       
        if p1<m:
            nums1[p1+p2:] = nums1_copy[p1:]
        if p2 < n :
            nums1[p1+p2:] = nums2[p2:]
################双指针（逆向）空间复杂度更小
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: void Do not return anything, modify nums1 in-place instead.
        """
        # two get pointers for nums1 and nums2
        p1 = m - 1
        p2 = n - 1
        # set pointer for nums1
        p = m + n - 1
        
        # while there are still elements to compare
        while p1 >= 0 and p2 >= 0:
            if nums1[p1] < nums2[p2]:
                nums1[p] = nums2