双指针算法：优化 LeetCode 题解

见解分享

2023-11-04 14:35:29

双指针算法：LeetCode 竞赛制胜法宝

掌握双指针算法，解锁 LeetCode 竞赛新境界

对于渴望提高 LeetCode 竞赛能力的程序员来说，掌握双指针算法至关重要。这种强大的算法可以帮助你高效解决各类问题，大幅提升你的解题效率。

什么是双指针算法？

双指针算法是一种算法范式，它利用两个指针在数据结构中移动，从而高效地解决问题。这种算法的精髓在于巧妙地利用指针同步或交替移动，以优化查找、比较和修改操作。双指针算法的优势在于其线性时间复杂度，使其在处理大型数据集时特别高效。

双指针算法在 LeetCode 中的应用

LeetCode 是一个广受欢迎的在线编码平台，为程序员提供了一个磨练算法和数据结构技能的绝佳环境。双指针算法在解决 LeetCode 问题中发挥着举足轻重的作用，尤其是以下几类问题：

1. 有序数组的 Two Sum

问题： 给定一个已排序的数组，找出两个数的和等于给定目标值的索引。

双指针解法： 利用双指针，一个指针从数组头开始，另一个指针从数组尾开始。如果指针指向的元素和等于目标值，则返回索引。否则，根据目标值的大小移动指针。

def twoSum(nums, target):
    left, right = 0, len(nums) - 1
    while left < right:
        sum = nums[left] + nums[right]
        if sum == target:
            return [left, right]
        elif sum < target:
            left += 1
        else:
            right -= 1
    return None

2. 两数平方和

问题： 给定一个整数数组，找出两个数的平方和最接近给定目标值的索引。

双指针解法： 类似于 Two Sum，使用双指针从数组两端向中间移动。计算当前指针指向元素的平方和，并与目标值比较。根据平方和的大小移动指针。

def twoSumClosest(nums, target):
    left, right = 0, len(nums) - 1
    min_diff = float('inf')
    result = None
    while left < right:
        sum = nums[left] ** 2 + nums[right] **  2
        diff = abs(sum - target)
        if diff < min_diff:
            min_diff = diff
            result = [left, right]
        if sum == target:
            return result
        elif sum < target:
            left += 1
        else:
            right -= 1
    return result

3. 反转字符串中的元音字符

问题： 给定一个字符串，反转字符串中的所有元音字符。

双指针解法： 使用两个指针，一个指向字符串头，另一个指向字符串尾。如果指针指向的字符是元音，则交换两个字符。继续移动指针，直到它们相遇。

def reverseVowels(s):
    left, right = 0, len(s) - 1
    vowels = {'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'}
    while left < right:
        if s[left] in vowels and s[right] in vowels:
            s[left], s[right] = s[right], s[left]
            left += 1
            right -= 1
        elif s[left] not in vowels:
            left += 1
        else:
            right -= 1
    return s

4. 回文字符串

问题： 判断一个字符串是否是回文，即从头读和从尾读都是一样的。

双指针解法： 使用两个指针，一个指向字符串头，另一个指向字符串尾。比较两个指针指向的字符，如果相等，则移动指针。直到指针相遇或字符不相等，则返回判断结果。

def isPalindrome(s):
    left, right = 0, len(s) - 1
    while left < right:
        if s[left] != s[right]:
            return False
        left += 1
        right -= 1
    return True

5. 归并两个有序数组

问题： 给定两个有序数组，将它们合并为一个有序数组。

双指针解法： 使用两个指针，一个指向第一个数组，另一个指向第二个数组。比较两个指针指向的元素，将较小的元素添加到新数组中。继续移动指针，直到遍历完两个数组。

def mergeSortedArrays(nums1, nums2):
    merged = []
    left, right = 0, 0
    while left < len(nums1) and right < len(nums2):
        if nums1[left] < nums2[right]:
            merged.append(nums1[left])
            left += 1
        else:
            merged.append(nums2[right])
            right += 1
    while left < len(nums1):
        merged.append(nums1[left])
        left += 1
    while right < len(nums2):
        merged.append(nums2[right])
        right += 1
    return merged

6. 判断链表是否存在环

问题： 给定一个链表，判断链表是否存在环。

双指针解法： 使用两个指针，一个指针一次移动一步，另一个指针一次移动两步。如果存在环，则两个指针最终会相遇。

def hasCycle(head):
    if not head or not head.next:
        return False
    slow, fast = head, head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        if slow == fast:
            return True
    return False

7. 最长子序列

问题： 给定两个字符串，找出这两个字符串的最长公共子序列。

双指针解法： 使用两个指针，一个指向第一个字符串，另一个指向第二个字符串。比较两个指针指向的字符，如果相等，则移动两个指针并递增公共子序列长度。否则，移动不匹配的指针。

def longestCommonSubsequence(s1, s2):
    lcs = 0
    left, right = 0, 0
    while left < len(s1) and right < len(s2):
        if s1[left] == s2[right]:
            lcs += 1
            left += 1
            right += 1
        else:
            if left > 0:
                left -= 1
            else:
                right += 1
    return lcs