以下题目均来自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

二、合并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

三、环形链表 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

四、环形链表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

五、链表的中间结点 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

六、删除链表的倒数第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

七、相交链表 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