指针

1.最接近的三数之和

python:

from typing import List


class Solution:
    def threeSumClosest(self, nums: List[int], target: int) -> int:
        nums.sort()
        min = abs(nums[0] + nums[1] + nums[2] - target)
        res = nums[0] + nums[1] + nums[2]
        for i in range(len(nums) - 2):
            l = i + 1
            r = len(nums) - 1
            while l < r:
                sum = nums[i] + nums[l] + nums[r]
                if abs(sum - target) < min:
                    min = abs(sum - target)
                    res = sum
                if sum > target:
                    r -= 1
                elif sum < target:
                    l += 1
                else:
                    return sum
        return res


if __name__ == '__main__':
    l = [-1, 2, 1, -4]
    j = Solution()
    a = j.threeSumClosest(l, 1)
    print(a)

• 一 解题思路:
  • 因为是三个数,首先找到一个界限,再从这个界限一个从左,一个往右,正好3个数,又因为是最接近的,用这3个数的和减去给定的数取绝对值,设第一次的这个差值为min(最小值),依次比较,有比它还小的,就替换,最后返回最后一次比较的值返回的结果!
• 二 应用范围—规律:
  • 比较适合 对撞指针 两个或两个以上比较
• 三 什么类型:
  • 双指针—对撞指针
• 四 注意点:
  • 1.先要排序
  • 2.一定不要忘记定义左右值
• 五 哪种类型—解决哪种问题:
  • 解决三数之和—最接近的三数之和

2.三数之和

python:

from typing import List


class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        res = []
        for i in range(len(nums) - 2):
            if i > 0 and nums[i - 1] == nums[i]:
                continue
            l = i + 1
            r = len(nums) - 1
            while l < r:
                if nums[i] + nums[l] + nums[r] > 0:
                    r -= 1
                elif nums[i] + nums[l] + nums[r] < 0:
                    l += 1
                else:
                    res.append([nums[i], nums[l], nums[r]])
                    while l < r and nums[l] == nums[l + 1]:
                        l += 1
                    while l < r and nums[r] == nums[r - 1]:
                        r -= 1
                    l += 1
                    r -= 1
        return res


if __name__ == '__main__':
    nums = [-1, 0, 1, 2, -1, -4]
    s = Solution()
    print(s.threeSum(nums))

• 一 解题思路:
  • 因为是三个数,首先找到一个界限,再从这个界限一个从左,一个往右,正好3个数,判断这3个数的和等于0吗,等于0就把他们添加进列表里面;不等于0,依次比较,小于0,往左走一位,大于0,往右走一位,直到等于0为止,返回列表的值!
• 二 应用范围—规律:
  • 比较适合 对撞指针 两个或两个以上比较
• 三 什么类型:
  • 双指针—对撞指针
• 四 注意点:
  • 1.先要排序
  • 2.一定不要忘记定义左右值
  • 3.记得去重
  • 左+=1,右-=1
• 五 哪种类型—解决哪种问题:
  • 解决三数之和—最接近的三数之和

3.删除指定元素

python:

from typing import List


class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        s = 0
        f = 0
        while f < len(nums):
            if nums[f] == val:
                f += 1
            else:
                nums[s] = nums[f]
                f += 1
                s += 1
        return s


if __name__ == '__main__':
    j = Solution()
    print(j.removeElement([3, 2, 2, 3], 3))

• 一 解题思路:
  • 因为删除指定元素,首先定义两个,分别是快慢指针,开始都指向第一个元素,因为快指针先走,所以循环条件是快指针f<总列表长度执行循环,当快指针指向的值为给定值时,让快指针,继续向后走一位,当满指针指向的值等于快指针指向的值时,把快指针的值赋值给满指针后继续让快慢指针向后同时走一位,直到快指针指向空,返回满指针的下标!
• 二 应用范围—规律:
  • 比较适合 快慢指针 两个进行比较
• 三 什么类型:
  • 双指针—快慢指针
• 四 注意点:
  • 1.最一开始快慢指针都是指向第一个
  • 2.循环条件是快指针<数组长度
  • 3.注意快指针!=给定值才赋值
  • 左+=1,右-=1
• 五 哪种类型—解决哪种问题:
  • 解决删除指定元素,移动0

4.移动零

python:

from typing import List


class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        s = 0
        f = 0
        while f < len(nums):
            if nums[f] == 0:
                f += 1
            else:
                nums[s] = nums[f]
                s += 1
                f += 1
        for i in range(s,len(nums)):
            nums[i] = 0
        return nums

if __name__ == '__main__':
    j = Solution()
    print(j.moveZeroes([0,1,0,3,12]))

• 一 解题思路:
  • 因为是移动0,首先定义两个,分别是快慢指针,开始都指向第一个元素,因为快指针先走,所以循环条件是快指针f<总列表长度执行循环,当快指针指向的值为0时,让快指针,继续向后走一位,当满指针指向的值等于快指针指向的值时,把快指针的值赋值给满指针后继续让快慢指针向后同时走一位,直到快指针指向空,返回列表,最后给要赋值的数赋值为0
• 二 应用范围—规律:
  • 比较适合 快慢指针 两个进行比较
• 三 什么类型:
  • 双指针—快慢指针
• 四 注意点:
  • 1.最一开始快慢指针都是指向第一个
  • 2.循环条件是快指针<数组长度
  • 3.注意快指针!=给定值才赋值
  • 4.注意最后不要忘记给后面元素赋值0
• 五 哪种类型—解决哪种问题:
  • 解决删除指定元素,移动0

5.两数之和

python:

from typing import List


class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        dict = {}
        for i in range(len(nums)):
            t = target - nums[i]
            if t in dict:
                return [dict[t],i]
            else:
                dict[nums[i]] = i

if __name__ == '__main__':
    j = Solution()
    print(j.twoSum([2, 7, 11, 15], 9))

• 一 解题思路:

  • 因为是两数之和,定义一个字典用于存储差值,首先遍历列表,用给定的数减去第一个值,看看字典里有没有这个值,如果有就返回这个key所对应的value和这个值的小标:如果没有,就添加到字典里面去,直到判断到字典里面有这个差值

• 二 应用范围—规律:

  • 比较适合 单指针

• 三 什么类型:

  • 单指针

• 四 注意点:

  • 1.字典里面存放的是值不是下标

• 五 哪种类型—解决哪种问题:

  • 解决两数之和

6.有序数组去重

python:

from typing import List


class Solution:
    def removeDuplicated(self, nums: List[int]) -> int:
        slow = 0
        fast = 1
        while fast < len(nums):
            if nums[fast] == nums[slow]:
                fast += 1
            else:
                slow +=1
                nums[slow] = nums[fast]
                fast += 1
        return slow + 1

• 一 解题思路:

  • 首先定义2个指针,一个是快指针,一个是慢指针,快指针第一次指向第二个元素,慢指针第一次指向第一个元素,快指针先去探索,故循环条件是快指针小于列表长度执行循环体,当慢指针指向的值等于快指针指向的值时,让快指针继续向后走一位,如果不相等,就让慢指针向后走一位再把快指针的值赋值给慢指针,因为如果先赋值后走的话就会把当前有用的值给覆盖掉,影响准确性,赋值之后再让快指针向后走一位,直到循环结束,返回慢指针下标加一

• 二 应用范围—规律:

  • 比较适合 双指针—快慢指针

• 三 什么类型:

  • 快慢指针

• 四 注意点:

  • 1.快指针先去探索
  • 2.先满指针+=1,再把快指针的值赋值给满指针

• 五 哪种类型—解决哪种问题:

  • 解决有序数组去重

7.判断链表是否有环

python

class Node:
    def __init__(self,data):
        self.data = data
        self.next = None

def pan(data):
    curr = data
    prev = data
    while curr and curr.next is not None:
        prev = prev.next
        curr = curr.next.next
        if prev == curr:
            return True
    return  False


if __name__ == '__main__':
    j1 = Node(1)
    j2 = Node(2)
    j3 = Node(3)
    j1.next = j2
    j2.next = j3
    j3.next = j1
    print(pan(j1))

• 一 解题思路:

  • 首先定义2个指针,一个是快指针,一个是慢指针,快指针第一次指向第一个元素,慢指针第一次也指向第一个元素,快指针先去探索一次走两步,慢指针一次走一步,循环条件是当快指针和慢指针都不为空执行循环体,判断快指针和慢指针想不想等,如果相等,就说明有环,如果到了循环结束也不行等,九说明没有环

• 二 应用范围—规律:

  • 比较适合 双指针—对撞指针

• 三 什么类型:

  • 对撞指针

• 四 注意点:

  • 1.判断函数(pan()是和class同级别)

• 五 哪种类型—解决哪种问题:

  • 解决链表是否有环