【算法训练】双指针技巧 leetcode python题解_prehead

以下题目均来自leetcode，会给出相应的题号和连接

一、合并两个有序链表 21

添加链接描述

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

1.分析

先创建一个虚拟头节点，然后遍历两条链表，选择其中较小的节点先加入新链表，然后指针后移。具体看代码。

2、代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        prehead = ListNode(-1) #虚拟头节点
        p = prehead
        p1 = list1
        p2 = list2
        while p1 and p2:  #依次遍历，按序加入新的链表中去
            if p1.val <= p2.val:
                p.next = p1
                p1 = p1.next
            else:
                p.next = p2
                p2 = p2.next
            p = p.next
        if p1 is not None: #将剩余的链表部分直接加入到新链表后
            p.next = p1
        else:
            p.next = p2
        return prehead.next
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

二、合并K个升序链表 23

添加链接描述给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

1、分析

其实是第一题的进阶，我们可以选择直接模拟，采用小根堆存放所有链表的节点值，保证根节点始终是最小的值。然后依次生成节点，添加到新的链表中去。
在python中 import heapq 是小根堆。具体见代码

2、代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        import heapq
        min_que = []
        prehead = ListNode(-1)
        p = prehead
        for item in lists:  #首先依次遍历所有的链表，将节点值存放到小根堆中
            while item:
                heapq.heappush(min_que,item.val)
                item = item.next
        while min_que:
            v = heapq.heappop(min_que) #依次取出小根堆的值，保证每次取出来的都是最小值
            node = ListNode(v)
            p.next = node
            p = p.next
        return prehead.next
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

三、环形链表 141

添加链接描述
给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

1、分析

采用快慢指针，如果在遍历的过程中快慢指针相遇，则一定是有环出现，否则没有环存在。
具体见代码

2、代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        fast,slow = head,head
        while fast and fast.next:  #采用快慢指针，若指针相遇证明有环。注意循环条件，都是针对fast的，因为fast不越界，slow肯定就不越界。
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                return True
        return False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

四、环形链表II 142

添加链接描述

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

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表

1、分析

仍然采用快慢指针，当二者第一次相遇的时候，假设慢指针走了k步，那么快指针一定走了2k步，而多走的这段路程是在环里面转圈，所以k一定是环大小的整数倍。假设相遇点距离环起点的距离是m，则从头节点走k-m就能到达环起点，而从相遇点走k-m步也能正好到达环起点。

因此在相遇之后，只需要将快慢指针的一个指针指向头节点，然后两个指针一起按照1的步长走k-m步就能到达环的起点了。
具体见代码。

2、代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        fast,slow = head,head
        while fast and fast.next:  #快慢指针先找到相遇点
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                break
        if not fast or not fast.next: #如果并非相遇退出，就没有环存在，直接返回None
            return None
        slow = head  
        while slow!=fast: #共同走k-m步达到环的起点
            slow = slow.next
            fast = fast.next
        return slow
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

五、链表的中间结点 876

添加链接描述
给定一个头结点为 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

1、分析

采用快慢指针，当快指针走到链表结尾的时候，慢指针正好走到中间节点（如果存在两个中间节点，那么slow指针指向的是第二个。

比较简单，直接上代码

2、代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def middleNode(self, head: ListNode) -> ListNode:
        fast,slow = head,head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
        return slow
1
2
3
4
5
6
7
8
9
10
11
12

六、删除链表的倒数第N个结点 19

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

1、分析

采用双指针，让一个指针先走n+1步，然后两个指针再一起走，当先走的指针走完链表的时候，后走的指针正好指向倒数第n个结点的前一个结点处。

此处要特别注意的是可能删除的是原链表的头节点，因此要创建虚拟头结点，并且两个指针都从虚拟头节点出发。

2、代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        prehead = ListNode(-1)  #采用虚拟头节点，防止删除的是原来链表的头节点
        prehead.next = head
        p1,p2 = prehead,prehead #都从虚拟头节点出发
        for _ in range(n+1): #让其中一个指针先走n+1步
            p2 = p2.next
        while p2:  #当先走的结点走完链表时，慢走的指针正好指向的时到处第n个结点的前一个结点
            p1 = p1.next
            p2 = p2.next
        p1.next = p1.next.next #删除倒数第n个结点
        return prehead.next
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

七、相交链表 160

添加链接描述
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

1、分析

采用双指针，首先分别指向两条链表，当访问完时接着到另一条链表的头部去，就相当于将两条链表串在了一起，这样两个指针就能同时进入公共部分。

2、代码

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        pa,pb = headA,headB
        while pa!=pb:
            pa = pa.next if pa else headB
            pb = pb.next if pb else headA
        return pa
1
2
3
4
5
6
7
8
9
10
11
12
13