Leetcode-双指针系列1

时间  2020-07-25
标签 leetcode 指针 系列 繁體版
原文   原文链接

15. 三数之和
16. 最接近的三数之和
18. 四数之和
26. 删除排序数组中的重复项
27. 移除元素
75. 颜色分类
88. 合并两个有序数组
21. 合并两个有序链表
剑指 Offer 21. 调整数组顺序使奇数位于偶数前面python

15. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出全部知足条件且不重复的三元组。算法

注意：答案中不能够包含重复的三元组。数组

示例：app

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

知足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]函数

咱们依然使用与两数之和相似的想法, 将三数之和转换为两数之和, 即首先须要固定第一个数, 而后去移动其他两个数, 而且为了方便, 首先将数组进行排序.指针

具体思路以下rest

  • 排序
  • 固定第一个数, 用p0表示. 使用另外两个指针p1, p2, 分别指向第一个数后面的元素和最后一个元素.
  • 当p0, p1, p2指向的元素之和大于0时, p2左移, 小于0时, p1右移, 不然, 将当前的3个元素添加到结果中. 当p1 = p2时, 结束循环. 回到第2步.

按照上述的思路, 能够写出以下的代码code

def ThreeSum(nums):
    if not sums or len(sums) < 3:
        return []
    
    nums.sort()
    n = len(nums)
    res = []
    for i in range(n-2):
        p1 = i + 1
        p2 = n - 1
        
        while p1 < p2:
            
            if nums[p1] + nums[p2] < -nums[i]:
                p1 += 1
            elif nums[p1] + nums[p2] > -nums[i]:
                p2 -= 1
            else:
                res.append([nums[i], nums[p1], nums[p2]])
                p1 += 1
                p2 -= 1
    return res

额, 看上去代码并无什么问题, 结构也还算清楚, 但其实存在一个较大的问题, 上述代码会获得重复的结果排序

好比一个排序数组[-4, -1, -1, 0, 1, 2]，上述代码会获得
[[-1,-1,2],[-1,0,1],[-1,0,1]]的结果, 所以咱们须要跳过第二个及之后的重复元素.three

def ThreeSum(nums):
    if not sums or len(sums) < 3:
        return []
    
    nums.sort()
    n = len(nums)
    res = []
    """
    若是第一个元素就大于0或者最后一个元素还小于0直接返回.
    """
    if nums[0] > 0 or nums[-1] < 0:
        return res
        
    for i in range(n-2):
        p1 = i + 1
        p2 = n - 1
        
        """ 
        去重
        """
        if i > 0 and nums[i] == nums[i-1]:
            continue
            
        while p1 < p2:
            
            if nums[p1] + nums[p2] < -nums[i]:
                p1 += 1
            elif nums[p1] + nums[p2] > -nums[i]:
                p2 -= 1
            else:
                res.append([nums[i], nums[p1], nums[p2]])
                """ 
                去重
                """
                while p1 < p2 and nums[p1] == nums[p1 + 1]:
                    p1 += 1
                while p1 < p2 and nums[p2] == nums[p2 - 1]:
                    p2 -= 1
                p1 += 1
                p2 -= 1

    return res

时间复杂度为$O(n^2)$, 空间复杂度为$O(1)$

16. 最接近的三数之和

给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在惟一答案。

示例：

输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

这题的思路和上一题的思路相似，一样是固定第一个数, 移动其他两个数, 代码很是一致. 而且还不用去重.

def threeSumClosest(nums, target):
    if not nums or len(nums) < 3:
        return []
        
    n = len(nums)
    
    # 排序
    nums.sort()
    res = []
    nearest_sum = sum(nums[:3])
    if nums[0] >= target:
        return sum(nums[:3])
        
    if nums[-1] <= target:
        return sum(nums[-3:])
        
    for i in range(n-2):
        p1 = i + 1
        p2 = n - 1
        
        while p1 < p2:
            temp = nums[i] + nums[p1] + nus[p2]
            
            if abs(temp - target) < abs(nearest_sum - target):
                nearest_sum = temp
                
            if temp < target:
                p1 += 1
            elif temp > target:
                p2 -= 1
            else:
                return target
                
    return nearest_sum

时间复杂度为$n^2$, 空间复杂度为$O(1)$

18. 四数之和

给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出全部知足条件且不重复的四元组。

注意：

答案中不能够包含重复的四元组。

示例：

给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。

知足要求的四元组集合为：
[
[-1, 0, 0, 1],
[-2, -1, 1, 2],
[-2, 0, 0, 2]
]

这题的思路仍是和上面几题的思路相同

def fourSum(nums, target):
    if not nums or len(nums) < 4:
        return []
    
    nums.sort()
    n = len(nums)
    res = []
    for i in range(n-3):
        # 去重
        if i > 0 and nums[i] == nums[i-1]:
            continue
        for j in range(i, n-2):
            p1 = j + 1
            p2 = n - 1
            
            # 去重
            if j > i and nums[j] == nums[j-1]:
                continue
                
            while p1 < p2:
                temp = nums[i] + nums[j] + nums[p1] + nums[p2]
                if temp < target:
                    p1 += 1
                elif temp > target:
                    p2 -= 1
                    
                else:
                    res.append([nums[i], nums[j], nums[p1], nums[p2]])
                    # 去重
                    while p1 < p2 and nums[p1] == nums[p1+1]:
                        p1 += 1
                        
                    while p1 < p2 and nums[p2] == nums[p2-1]:
                        p2 -= 1
                        
                    p1 += 1
                    p2 -= 1
    return res

时间复杂度为$O(n^3)$, 空间复杂度为$O(1)$

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

给定一个排序数组，你须要在 原地 删除重复出现的元素，使得每一个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

示例 1:
给定数组 nums = [1,1,2],

函数应该返回新的长度 2, 而且原数组 nums 的前两个元素被修改成 1, 2。
示例 2:
给定 nums = [0,0,1,1,1,2,2,3,3,4],

函数应该返回新的长度 5, 而且原数组 nums 的前五个元素被修改成 0, 1, 2, 3, 4。

你不须要考虑数组中超出新长度后面的元素。

这题要求原地修改数组, 那么显然, 咱们须要将重复的元素移动到数组末尾. 咱们可使用双指针来解决这个问题.

  • 设置两个指针p1, p2, 都初始化为0, 同时指向数组中第一个元素.
  • 当p1位置的元素和p2位置的元素相等时, p2右移, 不然p1右移, 而后交换两个位置的值, p2右移.
  • 重复执行第2步.
def removeDuplicates(nums):
    if not nums:
        return 0
    if len(nums) < 2:
        return 1
    
    # 同时指向第一个元素
    p1 = p2 = 0
    n = len(nums)
    while p2 < n:
        # 若是不相等, p1右移后， 交换两指针位置的值
        if nums[p2] != nums[p1]:
            p1 += 1
            nums[p2], nums[p1] = nums[p1], nums[p2]
        p2 += 1
        
    return p1 + 1

时间复杂度为$O(n)$, 空间复杂度为$O(1)$

27. 移除元素

给你一个数组 nums 和一个值 val，你须要 原地 移除全部数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序能够改变。你不须要考虑数组中超出新长度后面的元素。

示例 1:

给定 nums = [3,2,2,3], val = 3,

函数应该返回新的长度 2, 而且 nums 中的前两个元素均为 2。

你不须要考虑数组中超出新长度后面的元素。

示例 2:

给定 nums = [0,1,2,2,3,0,4,2], val = 2,

函数应该返回新的长度 5, 而且 nums 中的前五个元素为 0, 1, 3, 0, 4。

注意这五个元素可为任意顺序。

你不须要考虑数组中超出新长度后面的元素。
  • 设置两个指针, p1, p2, 同时初始化为0
  • 当p2元素不等于val时, 交换p1, p2位置元素. p1右移, p2右移
  • 当p2元素等于val时, p2右移
  • 回到第2步
def removeElement(nums, val):
    if not nums:
        return 0
    if len(nums) == 1:
        return int(nums[0] != val)
    
    n = len(nums)
    p1 = p2 = 0
    
    while p2 < n:
        if nums[p2] != val:
            nums[p1], nums[p2] = nums[p2], nums[p1]
            p1 += 1
        p2 += 1
        
    return p1

还能够用首尾2个指针来移动

  • 设定两个指针p1,p2, 分别指向0和n-1.
  • 若是p2位置元素等于val, 将其左移, 直至p2位置元素不等于val或者p2小于0.
  • 当p1位置元素等于val时, 交换p1, p2位置的值, p1右移, p2左移.
  • 当p2位置不等于val时, p1右移.
  • 重复2-4步骤, 直至p1大于p2
def removeElement(nums, val):
    if not nums:
        return 0
    if len(nums) == 1:
        return int(nums[0] != val)
    
    n = len(nums)
    p1 = 0
    p2 = n - 1
    
    # 这里须要有等号
    while p1 <= p2:
        while p2 > p1 and nums[p2] == val:
            p2 -= 1
        if nums[p1] == val:
            nums[p2], nums[p1] = nums[p1], nums[p2]
            p2 -= 1
            
        p1 += 1
        
    return p2 + 1

时间复杂度为$O(n)$, 空间复杂度为$O(1)$

75. 颜色分类

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

此题中，咱们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

注意:
不能使用代码库中的排序函数来解决这道题。

示例:

输入: [2,0,2,1,1,0]
输出: [0,0,1,1,2,2]

进阶：

  • 一个直观的解决方案是使用计数排序的两趟扫描算法。

    首先，迭代计算出0、1 和 2 元素的个数，而后按照0、一、2的排序，重写当前数组。

  • 你能想出一个仅使用常数空间的一趟扫描算法吗？

这题首先想到的应该是计数排序, 时间复杂度为$O(2n)$, 空间复杂度为$O(1)$.
但还有复杂度更低的方法, 一样仍是双指针.

  • 设置3个指针cur, p1, p2, 分别指向当前位置, 0的右边界和2的左边界, 初始化为0, 0, n-1.
  • 当cur位置元素为0, 交换p1, cur位置的元素, p1, cur同时右移
  • 当cur位置元素为2时, 交换p2, cur位置的元素, p2左移
  • 当cur位置元素为1时, cur右移.
  • 循环执行以上步骤, 直至cur 等于p2
def sortColors(nums):
    if not nums or len(nums) < 2:
        return 
    
    
    cur = p1 = 0
    p2 = len(nums) - 1
    
    while cur < p2:
        if nums[cur] == 0:
            nums[cur], nums[p1] = nums[p1], nums[cur]
            p1 += 1
            cur += 1
        # Note: 当cur位置的值等于2时, cur不须要右移, 由于交换以后并不能保证cur位置的值不等于2.
        elif nums[cur] == 2:
            nums[cur], nums[p2] = nums[p2], nums[cur]
            p2 -= 1
        else:
            cur += 1

时间复杂度为$O(n)$, 空间复杂度为$O(1)$

88. 合并两个有序数组

给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。

说明:

  • 初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。
  • 你能够假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。

示例:

输入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3

输出: [1,2,2,3,5,6]

最直观, 最简单的方式就是合并再排序, 对应的时间复杂度为$O((m+n)log(m+n))$

但其实咱们可使用双指针进一步下降复杂度

  • 设置两个指针p1, p2, 分别指向nums1的m-1和nums2的n-1位置.
  • 当p1位置元素大于p2位置元素时, 将nums1的m+n-1位置的值者只为p1位置的值, p1左移, 不然将nums1的m+n-1位置的值者只为p2位置的值, p2左移.
  • 回到上一步, 直至p1<0或者p2<0
def merge(nums1, m, nums2, n):
    if not nums2:
        return nums1
    
    i = m - 1
    j = n - 1
    
    while i >= 0 and j >= 0:
        if nums1[i] > nums[j]:
            nums1[i+j+1] = nums1[i]
            i -= 1
        else:
            nums1[i+j+1] = nums2[j]
            j -= 1
    if j >= 0:
        nums1[:j] = nums2[:j]
    return nums1

时间复杂度为$O(m)$或者$O(n)$, 空间复杂度为$O(1)$

21. 合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是经过拼接给定的两个链表的全部节点组成的。 

示例：
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4 
def mergeTwoLists(l1, l2):
    
    p1 = l1
    p2 = l2
    
    # 初始化为一个临时节点
    p0 = new_ln = ListNode(-1)
    while p1 and p2:
        if p1.val < p2.val:
            p0.next = p1
            p1 = p1.next
        else:
            p0.next = p2
            p2 = p2.next
        p0 = p0.next
    if p1:
        p0.next = p1
    if p2:
        p0.next = p2
        
    return new_ln.next

时间复杂度为$O(n)$, 空间复杂度为$O(1)$

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得全部奇数位于数组的前半部分，全部偶数位于数组的后半部分。

示例：

输入：nums = [1,2,3,4]
输出：[1,3,2,4]
注：[3,1,2,4] 也是正确的答案之一。
  • 使用两个指针p1, p2, 分别初始化为0, n-1
  • 当p1位置元素为奇数时, p1右移;
  • 当p2位置元素为偶数时, p2左移
  • 不然交换p1, p2位置元素.
def exchange(nums):
    if not nums or len(nums) < 2:
        return nums
    
    n = len(nums)
    
    p1 = 0
    p2 = n - 1
    while p1 < p2:
        if nums[p1] % 2:
            p1 += 1
        elif not nums[p2] % 2:
            p2 -= 1
        else:
            nums[p1], nums[p2] = nums[p2], nums[p1]
            
    return nums

一样, 快慢指针也能够解决问题

def exchange(self, nums: List[int]) -> List[int]:
    if not nums or len(nums) < 2:
        return nums
    
    n = len(nums)
    p2 = p1 = 0
    while p2 < n:
        if nums[p2] %2:
            nums[p1], nums[p2] = nums[p2], nums[p1]
            p1 += 1
        p2 += 1
    return nums

时间复杂度为$O(n)$, 空间复杂度为$O(1)$

总结

双指针的思路在数组和链表的题目中有着普遍的应用, 这里主要介绍了数组中应用.

双指针分为两种, 快慢指针(这里将移动频率不同的称为快慢指针)和首尾指针. 首尾指针主要在数组中使用, 快慢指针在数组和链表中都有普遍应用.

快慢指针的基本思路是

  • 同时初始化为0或者链表头节点
  • 当前元素不知足条件时, 交换快慢指针指向的值; 慢指针右移, 快指针右移
  • 不然, 快指针右移
  • 重复2-3步骤

而首尾指针, 一般须要先将数组排序, 好比3数之和,4数之和等 而后根据具体状况选择移动首指针或者尾指针, 直至知足条件.

水平有限, 不免有错误或不足的地方. 还请不吝赐教.

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程