python 链表相关

列表转链表

尾插法

res = [1,2,3,4,5]
# 以res列表第一项为新节点创建链表
head = ListNode(res[0])
# 尾插法
p = head
for i in range(1, len(res)):
	# 节点下一项为值为res[i]的新节点
    p.next = ListNode(res[i])
    # 遍历
    p = p.next
return head

头插法

res = [1,2,3,4,5]
# 以res列表第一项为新节点创建链表
head = ListNode(res[0])
# 头插法
for i in range(1, len(res)):
	# 新节点p，值为res[i]
	p = ListNode(res[i])
	# p的next指向链表头
    p.next = head
    # 更新链表头为新节点
    head = p
return head

链表转列表

# l1为链表
n1 = l1
li1 = []
while n1:
	 li1.append(n1.val)
	 n1 = n1.next
return li1

链表中间节点

# 快慢指针
slow = fast = head
# 快指针条件
while fast.next and fast.next.next:
    slow = slow.next
    fast = fast.next.next
return slow

从中间分割列表

def split(head: ListNode) -> ListNode:
    slow, fast, prev = head, head, None
    while fast and fast.next:
        prev, slow, fast = slow, slow.next, fast.next.next
    # 将前半部分与后半部分断开
    prev.next = None
    return slow
mid = split(head)
left = head
right = mid

链表是否有环

# 如果为空或者只有单一节点
if not head or not head.next:
     return False
# 快慢指针
slow = fast = head
while fast.next and fast.next.next:
    slow = slow.next
    fast = fast.next.next
    # 判断slow是否与fast相同，来判断是否有环
    if slow == fast:
        return True
return False

链表反转

# 设置prev指向为空
prev = None
# 设置当前为head
curr = head
# 当curr不为空，遍历节点， (我使用列表解释仅仅为了方便)
while curr:
	# 临时节点保存curr下一个节点
	# 例如链表如果是[1,2,3,4], 那么保存从2开始的节点[2,3,4]
    nextTemp = curr.next
    # curr下一个节点为当前prev节点值
    # 同样的，[1,2,3,4],curr.next 代表的是[2,3,4], 那么让curr.next = prev
    # 如果prev是None,那么代表curr下一个节点是空, curr = [1], 第二次curr.next = [1],curr =[2,1],以此类推
    # 意思就是curr是[1]，与[2,3,4]断开了连接
    curr.next = prev
    # 更新prev节点为curr值，是链表的返回值，就相当于是把每次curr的值赋值给prev
    prev = curr
    # 把当前curr 重新设置为nextTemp
    # 第一次遍历相当于把[1]给到prev后，剩下的[2,3,4]继续遍历
    # 第二次[2,1]
    # 第三次[3,2,1]
    # 最后一次[4,3,2,1]
    curr = nextTemp
return prev

合并链表

# 判断链表n1是否为空，为空直接返回n2
if not n1:
   return n2
# 同上
if not n2:
   return n1
# 找到n1的尾部节点
current = n1
while current.next:
   current = current.next
# 连接n2
current.next = n2
# 返回连接后的节点
return n1

合并两个有序链表

# 创建一个哑节点作为新链表的头部
dummy = ListNode(-1)
# 用于遍历新链表
current = dummy
# 合并时排序
while l1 and l2:
    if l1.val <= l2.val:
        current.next = l1
        l1 = l1.next
    else:
        current.next = l2
        l2 = l2.next
    current = current.next

# 将剩余部分链接到新链表
if l1:
    current.next = l1
if l2:
    current.next = l2

return dummy.next  # 返回新链表的头节点

def merge(l1: ListNode, l2: ListNode) -> ListNode:
    # 创建一个哑节点作为新链表的起始
    dummy = ListNode(0)
    # 尾指针, 用于构建新链表
    tail = dummy
    while l1 and l2:
        if l1.val < l2.val:
        	# 将l1的当前节点连接到新链表, l1指针向后移
            tail.next, l1 = l1, l1.next
        else:
        	# 将l2的当前节点连接到新链表, l2指针向后移
            tail.next, l2 = l2, l2.next  
        # 尾指针后移
        tail = tail.next  
    # 连接剩余的部分
    tail.next = l1 or l2  
    # 返回哑节点的下一个节点，即新链表的头节点
    return dummy.next  

merge(l1,l2)