数据结构与算法-双指针法

学习计划：3个月内算法小成，完成leetcode hot100

当前进度：学完数组、链表

刷题语言：Python

时间：2025/02/17-2025/03/31

五、双指针法

学习链接：代码随想录

双指针法是一种算法思想，总结了前面数组，链表，哈希表，字符串的内容

1、移除元素

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

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

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。

思路：快慢指针法，两个指针都从第一个元素开始，快指针遍历一遍数组，如果快指针元素不是val，那就借助慢指针将其保存到数组最左边。

（为什么保存在最左边而不是最右边，因为如果慢指针在最右边，那么还需要先判断最右边的元素是不是val，同时对于0个元素或者1个元素的数组需要另外判断）

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

        return slow

时间复杂度O(n)

空间复杂度O(1)

2、反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：
输入：["h","e","l","l","o"]
输出：["o","l","l","e","h"]

思路：前后双指针，交换前后双指针元素，并且指针向中间移动

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        left,right = 0,len(s)-1

        while left<right:
            s[left],s[right]=s[right],s[left]
            left+=1
            right-=1

3、翻转字符串里的单词

给定一个字符串，逐个翻转字符串中的每个单词。

示例 1：
输入: "the sky is blue"
输出: "blue is sky the"

示例 2：
输入: "  hello world!  "
输出: "world! hello"
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。

思路：与反转字符串一样，但是需要先分割单词

class Solution:
    def reverseWords(self, s: str) -> str:
        words = s.split()
        print(words)

        left,right=0,len(words)-1
        while left<right:
            words[left],words[right]=words[right],words[left]
            left+=1
            right-=1

        return ' '.join(words)

4、反转链表

题意：反转一个单链表。

示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

思路：熟悉定义链表，链表每个节点cur包括了下一个节点指针cur.next，反转就是修改每个节点的指针，使其指向上一个节点，那么就要提前定义上一个节点pre，第一个节点头节点head的上一个节点是None，第一个节点的上一个节点是第一个节点，以此类推，直至找到最后一个节点，最后一个节点的下一个节点是None。

# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
        
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        cur = head
        pre = None
        while cur:
            tmp = cur.next
            cur.next = pre

            pre = cur
            cur = tmp
        return pre

5、删除链表的倒数第N个节点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

进阶：你能尝试使用一趟扫描实现吗？

示例 1：输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5]

思路：使用双指针得到倒数第n个节点的位置：首先然fast移动n+1步，然后fast和slow同时移动，知道fast到达尾部指向的null时，此时slow.next=倒数第n个节点

注意：需要注意极端情况，如链表只有一个元素或者两个元素时，此时加上虚拟头节点就可以不用考虑了。

#自定义单链表类
class ListNode:
    def __init__(self,val=0,next=None):
        self.val = val
        self.next = next

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:

        tmp = ListNode(0,head)
        fast = slow = tmp

        for i in range(n+1):
            fast = fast.next

        while fast:
            slow = slow.next
            fast = fast.next
        
        slow.next = slow.next.next

        return tmp.next

        

6、链表相交

        给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

思路1：先求出两个链表的长度差值，使用两个指针分别在A和B上同时移动。

思路2：当链表A的指针变量完链表A之后，指向链表B；当链表B的指针变量完链表B之后，指向链表A；如果两个链表有交点，那么一点在第一个交点处相遇

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        curA = headA
        curB = headB
        while curA!=curB:
            curA = curA.next if curA else headB
            curB = curB.next if curB else headA

        return curA

补充：Python 中的条件表达式（也称为三元运算符）

curA = curA.next if curA else headB
如果curA不是null，则curA = curA.next
如果curA等于null，则curA = headB

7、环形链表

题意： 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

思路 ：定义快慢指针，快指针每次走两个节点，慢指针每次走一个节点，如果有环的话，快慢指针一定在环中某个节点相遇（确定环存在）。重新定义两个指针，一个从head节点出发，一个从相遇节点出发，最后一定在环的入口节点处相遇（确定环入口）。

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        slow = fast = head
        while fast.next:
            fast = fast.next.next #fast走得快，slow走得慢
            slow = slow.next
            if fast==slow: #相遇说明环存在
                slow = head 
                while fast!=slow:   #令slow从head开始，fast从相遇点开始同时出发，最后一定在环入口处相遇
                    fast = fast.next
                    slow = slow.next
                return fast
        return None