Python数据结构与算法系列---双指针

最新推荐文章于 2023-02-21 17:45:30 发布

写的不是代码

最新推荐文章于 2023-02-21 17:45:30 发布

阅读量442

点赞数

分类专栏： python 机器学习文章标签：数据结构算法

本文链接：https://blog.csdn.net/Melo0705/article/details/113468503

版权

python 机器学习专栏收录该内容

8 篇文章 3 订阅

订阅专栏

本文介绍了双指针技术在数组操作中的多种应用场景，如寻找两数之和、判断平方和的存在、反转字符串中的元音、验证回文字符串以及找到最长匹配字典单词。每个案例都详细阐述了解题思路，并给出了相应的Python代码实现，展示了双指针如何有效地解决这些复杂问题。

摘要由CSDN通过智能技术生成

双指针主要用于数组遍历，两个指针指向不同的元素，从何协同完成任务

1：两数之和 II - 输入有序数组

输入: numbers = [2, 7, 11, 15], target = 9
输出: [1,2]
解释: 2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。

class Solution(object):
    def twoSum(self, numbers, target):
        """
        :type numbers: List[int]
        :type target: int
        :rtype: List[int]
        """
        res = []
        left = 0
        right = len(numbers) - 1
        while left < right:
            curSum = numbers[left] + numbers[right]
            if curSum == target:
                res.append(left + 1)
                res.append(right + 1)
                break;
            elif curSum < target:
                left += 1
            else:
                right -= 1
        return res

2：平方数之和

给定一个非负整数 c ，你要判断是否存在两个整数 a 和 b，使得 a2 + b2 = c 。

输入：c = 5
输出：true
解释：1 * 1 + 2 * 2 = 5

思路：此题看做元素为 0~target 的有序数组中查找两个数，使得这两个数的平方和为 target。求平方根去剪枝。存在left==right的可能

class Solution(object):
    def judgeSquareSum(self, c):
        """
        :type c: int
        :rtype: bool
        """
        left = 0
        right = int(c**0.5) 
        while left <= right:
            curSum = left * left + right * right
            if curSum == c:
                return True
            elif curSum < c:
                left += 1
            else:
                right -= 1
        return False

3：反转字符串中的元音字母

输入："leetcode"
输出："leotcede"

class Solution(object):
    def reverseVowels(self, s):
        """
        :type s: str
        :rtype: str
        """
        ele = ['a', 'A', 'i', 'I', 'o', 'O', 'u', 'U', 'e', 'E']
        left = 0
        right = len(s) - 1
        nums = list(s)
        while left < right:
            e_left = nums[left]
            e_right = nums[right]
            if e_left not in ele:
                left += 1
            elif e_right not in ele:
                right -= 1
            else:
                nums[left], nums[right] = e_right, e_left
                left += 1
                right -= 1
        return ''.join(nums)

4：验证回文字符串 Ⅱ

给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串。

输入: "abca"
输出: True
解释: 你可以删除c字符。

思路：双指针；当相等时，继续往中心走；当不相等时，删除一个字符（或左或右），接着继续看是不是相等；

class Solution(object):
    def isPalindrome(self, s):
        left = 0
        right = len(s) - 1
        while left < right:
            if s[left] == s[right]:
                left += 1
                right -= 1
            else:
                return False
        return True

    def validPalindrome(self, s):
        """
        :type s: str
        :rtype: bool
        """
        left = 0
        right = len(s) - 1
        while left < right:
            if s[left] == s[right]:
                left += 1
                right -= 1
            else:
                return self.isPalindrome(s[left:right]) or self.isPalindrome(s[left + 1:right + 1])
        return True

5: 通过删除字母匹配到字典里最长单词

给定一个字符串和一个字符串字典，找到字典里面最长的字符串，该字符串可以通过删除给定字符串的某些字符来得到。如果答案不止一个，返回长度最长且字典顺序最小的字符串。如果答案不存在，则返回空字符串。

输入:
s = "abpcplea", d = ["ale","apple","monkey","plea"]

输出: 
"apple"

思路： 1：利用双指针判断是不是子字符串 2：进行大小的判断和字典序的判断

class Solution(object):
    def isSubStr(self, s, sub):
        i = 0
        j = 0
        while i < len(s) and j < len(sub):
            if s[i] == sub[j]:
                j += 1
                i += 1
            else:
                i += 1
        return j == len(sub)

    def compare(self, sub, maxStr):
        l1 = len(sub)
        l2 = len(maxStr)
        if l1 < l2:
            return maxStr
        elif l1 > l2:
            return sub
        return min(sub, maxStr)

    def findLongestWord(self, s, d):
        """
        :type s: str
        :type d: List[str]
        :rtype: str
        """
        maxStr = ""
        for sub in d:
            if self.isSubStr(s, sub):
                maxStr = self.compare(sub, maxStr)

        return maxStr