基础知识
链表可以被想象为一系列的节点,每个节点至少有一个指针指向下一个节点,在最后一个节点,用null pointer来表示链表的结束。
链表的创建速度通常很快,在表头和表尾的插入也很快(O(1)),但是销毁和搜索查找则很慢(O(n))。
解题技巧
PreNode的使用
题目: . - 力扣(LeetCode)
介绍: 在链表中,经常会通过在链表前面插入一个节点的形式,来让之后的讨论变得简单。比如下面的这道题, 由于对于节点进行两两交换,将会造成head节点的更换,如果利用prenode,可以避免复杂的分类讨论。
# 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]:
cur_node = ListNode()
cur_node.next = head
pre_node = cur_node
while(cur_node and cur_node.next and cur_node.next.next):
next_node = cur_node.next
next2node = next_node.next
cur_node.next = next2node
tmp_node = next2node.next
next2node.next = next_node
next_node.next = tmp_node
cur_node = next_node
return pre_node.next
快慢指针,链表反转
题目名称: 重排链表
介绍:本题的目标是将链表进行重新组合,如下图。
如果按照标准的解法,我们需要实现三步
1. 链表中点的获取
2. 链表的反转
3. 链表的插入
而每一步都是比较经典的链表操作。
首先,为了获取链表中点,我们可以通过快慢链表。
def getMidNode(head: ListNode)->ListNode:
fast_node = head
slow_node = head
while(fast_node.next.next and slow_node.next):
fast_node = fast_node.next.next
slow_node = slow_node.next
return slow_node
然后,我们需要进行链表的反转。
def reverseList(head: ListNode)->ListNode:
prev_node = None
cur_node = head
while(cur_node):
next_node = cur_node.next
cur_node.next = prev_node
prev_node = cur_node
cur_node = next_node
return prev_node
其中需要注意的是,我们要存储prev_node, next_node; 在while循环中,我们每次需要判断cur_node, 但是更重要的是,在最后一次,cur_node必然为空,因此,最后需要返回的是prev_node.
最后,我们需要实现列表的融合。
对应的就是 A--> B 和 C--> D, 变为 A-->C --> B --> D . 为了实现这一操作, 我们每次需要对于两个链表的next node进行备份,然后再更改current node的相互关系,然后再去处理next node。
def mergeLists(headA:ListNode, headB:ListNode):
curA = headA
curB = headB
while(curA and curB):
tmpA = curA.next
tmpB = curB.next
curA.next = curB
curB.next = tmpA
curA = tmpA
curB = tmpB
return headA
实现了这些子模块后,我们经过整合,就可以实现最后的功能。为了把两个链表进行拆分,我们需要将中间节点的next在备份之后,设定为0。
midNode = getMidNode(head)
headA = head
headB = midNode.next
midNode.next = None
headB = reverseList(headB)
result = mergeLists(headA, headB)
return result
分而治之 divide and conquer
参考链接: 23. 合并 K 个升序链表
这题同样经典,将多个链表合并的问题,通过对于list的长度的判断,进行分而治之。基本单元是对于两个链表进行排序和和合并,这考验的是链表的基本功。
class Solution:
def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
def mergeTwoLists(headA, headB):
head = ListNode()
cur_node = head
while(headA and headB):
if(headA.val <= headB.val):
tmp = headA.next
cur_node.next = headA
cur_node = headA
headA = tmp
else:
tmp = headB.next
cur_node.next = headB
cur_node = headB
headB = tmp
if(headA):
cur_node.next = headA
elif(headB):
cur_node.next = headB
return head.next
n = len(lists)
if n == 0: return None
if n == 1: return lists[0]
left = self.mergeKLists(lists[:n//2])
right = self.mergeKLists(lists[n//2:])
return mergeTwoLists(left, right)
参考链接:
https://www.cs.princeton.edu/courses/archive/spr11/cos217/lectures/08DsAlg.pdf