链表

1. 双指针

（通常需要配合虚拟头结点）

• 合并2个有序列表

(双指针比较节点)

• 合并k个有序列表

（配合最小堆）

• 涉及倒数第k个节点

（快指针先走）

• 单链表中点

（快指针是慢指针两倍速度）

• 链表是否成环

（快指针是慢指针两倍速度，最终相遇）

• 计算链表环起点

（相遇后慢指针回到起点，再相遇）

• 链表是否相交

a,b,k 分别为A的长，B的长，公共长，则a + (b - k) = b + (a - k)

• 反转链表

def reverse(head)
    pre, cur = None, head
    while cur:
        cur.next, pre, cur = pre, cur, cur.next
    return pre

• 反转前n个节点

def reverse(head, n)
    pre, cur = None, head
    i = 1
    while cur:
        cur.next, pre, cur = pre, cur, cur.next
        i += 1
        # 反转n节点后结束
        if i > n:
            break
    # 将头结点指向n+1节点
    head.next = cur

    return pre

• 反转第m到第n个节点

def reverse(head, m, n)
    # 记录m-1节点和m节点
    cur = head
    i = 1
    if m <= 1:
        nodem1, nodem = None, head
    else:
        while cur:
            if i > m:
                break
            i += 1
            cur = cur.next
        nodem1, nodem = cur, cur.next

    # 从m节点开始反转
    pre, cur = nodem1, nodem
    i = 1
    while cur:
        cur.next, pre, cur = pre, cur, cur.next
        i += 1
        # 反转n节点后结束
        if i > n - m + 1:
            break
    # 将m-1节点指向n节点，如果m=1,则n节点为头结点
    if m <= 1:
        head = pre
    else:
        nodem1.next = pre
    # 将m节点指向n+1节点
    nodem.next = cur

    return head

2. 递归

• 反转链表

def reverse(head)
    if not head or not head.next:
        return head
    last = reverse(head.next)
    head.next.next = head
    head.next = None
    return last

• 反转前n个节点

def reverseN(head, n)
    if n == 1:
        # 记录n+1节点
        noden1 = head.next
        return head
    last = reverseN(head.next, n-1)
    head.next.next = head
    head.next = noden1
    return last

• 反转第m到第n个节点

def reverseBetween(head, m, n)
    if m == 1:
        reverseN(head, n)
    head.next = reverseBetween(head.next, m-1, n-1)
    return head

• 每n个一组进行反转，不足的不反转

def reverseN(head: Node, n):
    pre, cur = None, head
    i = 1
    while cur and i <= n:
        cur.next, pre, cur = pre, cur, cur.next
        i += 1
    head.next = cur
    return pre, cur


def reverseNGroup(head: Node, n):
    a = head
    for i in range(n):
        if not a:
            return head
        a = a.next
        i += 1
    new_head, next_head = reverseN(head, n)
    head.next = reverseNGroup(next_head, n)
    return new_head