24. 两两交换链表中的节点
题目:
给你一个链表,两两交换其中相邻的节点,并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题(即,只能进行节点交换)。
示例 1:输入:head = [1,2,3,4] 输出:[2,1,4,3]
示例 2:输入:head = [] 输出:[]
示例 3:输入:head = [1] 输出:[1]
思路:
设置虚拟头节点,创建临时结点保存结点1和结点3,考虑到奇数、偶数、空链表的情况,确定遍历何时结束。
代码:
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
dummy_head = ListNode(next=head) # 创建虚拟头节点的方式,需要熟练掌握
cur = dummy_head
while cur.next != None and cur.next.next != None:
temp = cur.next # 临时节点,保存结点1
temp1 = cur.next.next.next # 保存结点3
cur.next = cur.next.next # 虚拟头节点指向结点2
cur.next.next = temp # 结点2指向结点1
temp.next = temp1 # 结点1指向结点3
cur = cur.next.next # 结点后移,该处理下一对数字
return dummy_head.next
19.删除链表的倒数第N个节点
题目:
给你一个链表,删除链表的倒数第 n
个结点,并且返回链表的头结点。
示例1: 输入:head = [1,2,3,4,5], n = 2 输出:[1,2,3,5]
示例 2: 输入:head = [1], n = 1 输出:[]
示例 3: 输入:head = [1,2], n = 1 输出:[1]
思路:
利用快慢双指针的方法。画图!
# 快指针比慢指针先走n+1步。这一步对我来说比较难且重要。
for i in range(n + 1):
fast = fast.next
代码:
# 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: Optional[ListNode], n: int) -> Optional[ListNode]:
dummy_head = ListNode(next=head) # 创建虚拟头节点
fast = dummy_head
slow = dummy_head
# 快指针比慢指针先走n+1步。这一步对我来说比较难且重要。
for i in range(n + 1):
fast = fast.next
# 移动两个指针,直到快指针指向空
while fast!=None:
slow = slow.next
fast = fast.next
# 删除的动作
slow.next = slow.next.next
return dummy_head.next
面试题 02.07. 链表相交
题目:
给你两个单链表的头节点 headA
和 headB
,请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点,返回 null
。
示例:
输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出:Intersected at '8'
解释:相交节点的值为 8 (注意,如果两个链表相交则不能为 0)。
从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,0,1,8,4,5]。 在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。
思路:
方法:双指针,让两个指针把两个链表都走一遍,如果有next相等的情况,就相交。
重点:判断相等的是指针,不是数值。
代码:
1、
# 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:
lenA, lenB = 0, 0
cur = headA # 指向A的头节点
while cur:
cur = cur.next
lenA += 1
cur = headB # 指向B的头节点
while cur:
cur = cur.next
lenB += 1
curA, curB = headA, headB
if lenA>lenB:
curA,curB=curB,curA
lenA,lenB=lenB,lenA
for _ in range(lenB-lenA):
curB=curB.next
while curA:
if curA==curB:
return curA
else:
curA=curA.next
curB=curB.next
return None
2、在B站中找到相关视频,得到一种简单的操作:
# 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:
A=headA
B=headB
while A!=B:
A=A.next if A else headB # A往后面走,当A指向空,就跳到B上面继续走
B=B.next if B else headA # 同上
return B
142.环形链表II
题目:
给定一个链表的头节点 head
,返回链表开始入环的第一个节点。 如果链表无环,则返回 null
。
如果链表中有某个节点,可以通过连续跟踪 next
指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos
来表示链表尾连接到链表中的位置(索引从 0 开始)。如果 pos
是 -1
,则在该链表中没有环。
注意:1、pos
不作为参数进行传递,仅仅是为了标识链表的实际情况。2、不允许修改 链表。
示例:
输入:head = [3,2,0,-4], pos = 1
输出:返回索引为 1 的链表节点
解释:链表中有一个环,其尾部连接到第二个节点。
思路:
1、利用快慢指针,开始都指向头节点,后面慢指针每次走一步,快指针走两步。
2、目的是为了找环的起点,第一次相遇后,要把慢指针重新指向头节点,第二次相遇的点就是起点。(目前只能说知道思路,但是感觉理解的不是很透彻。)
代码:
快慢指针方法:
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
# 定义快慢指针,开始都指向头节点
slow = head
fast = head
while fast and fast.next: # 快指针和快指针的下一个结点不为空时
slow = slow.next
fast = fast.next.next
if slow == fast:
# 当两指针第一次相遇,慢指针指向头节点,这是为了寻找环的起点。
# 当二者再次相遇,就在环的起点相遇
slow = head
while slow != fast: # 没有相遇,一直往前走,相遇的时候,返回慢指针
slow = slow.next
fast = fast.next
return slow
return None # 当快指针或者快指针下一个结点指向空,直接返回空
链表的总结
链表最重要的是要确定数值和指针,要学会巧用虚拟头节点和临时结点。同时双指针的用法也要因题而异。