算法：链表

区分数组与链表

• 数组是连续的，一般开始有指定大小。Index访问，O(1)查询。只记录第一个位置。
• 链表是离散的，要多少，加多少。访问只能从头开始，不循序随随机访问。
• 数组：找O(1)，插入O(n)；链表：找O(n)，插入O(1)。

解题关键：

• 画图
• 设置哨兵节点
• 创建指针：pre、cur、next、tmp、head、tail。基本就这些

题目

203. 移除链表元素

    def removeElements(self, head: ListNode, val: int) -> ListNode:
        node = ListNode(0)
        node.next = head
        pre,cur = node , head
        while cur:
            if cur.val == val: #当前值 == val
                pre.next = cur.next #前一个指针的下一项指向后一个【原本是指向当前的】
                cur = cur.next     #当前的指向下一个
            else:
                pre =pre.next
                cur = cur.next
        return node.next

技巧：双指针，增加一个哨兵节点，便于处理边界情况；

876. 链表的中间结点

    def middleNode(self, head: ListNode) -> ListNode:
        slow = head
        fast = head
        while slow and fast:
            if fast.next is None:
                break
            elif fast.next.next is None:  #偶数的情况 ，因为是第二个中间结点，所以要多走一次
                fast = fast.next
            else:
                fast = fast.next.next          
            slow = slow.next       
        return slow

技巧：快慢指针
【没有限制的话，也可以输入到列表，返回中间结点】

142. 环形链表 II

    def detectCycle(self, head: ListNode) -> ListNode:
        slow = head 
        fast = head 
        flag = False
        while fast is not None and fast.next is not None:
            slow = slow.next 
            fast = fast.next.next
            if slow == fast:
                flag = True
                fast = head
                break
        if not flag:
            return None     
        while fast != slow:
            slow = slow.next
            fast = fast.next
        return slow 

同样用快慢指针，相遇时，设置其中一个从头开始走，再次相遇即为环的起始点。
【画个图就明白了】

快慢指针对于找倒数第N个元素同理，先走N步，再一起走。

面试题25. 合并两个排序的链表

    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        p = dummy =  ListNode(0)
        while l1 and l2 :
            if l1.val <= l2.val:
                p.next = l1
                l1 = l1.next
            else:
                p.next = l2
                l2 = l2.next
            p = p.next #这个不能遗漏 
        p.next = l1 if l1 else l2 
        return dummy.next

147. 对链表进行插入排序

    def insertionSortList(self, head: ListNode) -> ListNode:
        dummy = ListNode(0)
        cur = head
        while  cur :
            pre = dummy
            while pre.next and pre.next.val <= cur.val:
                pre = pre.next
            tmp = cur.next
            cur.next = pre.next
            pre.next = cur 
            cur = tmp
        return dummy.next

注意下，每次是从头开始遍历，是在第一个while循环中将指针重新指向创建的哨兵节点。

148. 排序链表

归并排序：
链表拆分+有序链表合并

    def sortList(self, head: ListNode) -> ListNode:
        if head is None or head.next is None :
            return head 
        mid = self.getmid(head)
        rhead = mid.next
        mid.next = None
        s_l = self.sortList(head)
        s_r = self.sortList(rhead)
        return self.merge(s_l,s_r)
    #链表拆分，快慢指针
    def getmid(self,head):
        if head is None :
            return head            
        slow = head
        fast = head
        while fast.next and fast.next.next:
            slow = slow.next
            fast = fast.next.next
        return slow
    def merge(self, l1, l2) : #链表合并
        p = dummy =  ListNode(0)
        while l1 and l2 :
            if l1.val <= l2.val:
                p.next = l1
                l1 = l1.next
            else:
                p.next = l2
                l2 = l2.next
            p = p.next #这个不能遗漏 
        p.next = l1 if l1 else l2 
        return dummy.next

反转链表

    def reverseList(self, head: ListNode) -> ListNode:
        cur = head
        pre = None
        ntx = None
        while cur :
            ntx = cur.next
            cur.next = pre
            pre = cur 
            cur = ntx 
        return pre

反转链表在于设置好当前、前一个、后一个节点，然后画图，即可。

92. 反转链表 II

反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。

说明:
1 ≤ m ≤ n ≤ 链表长度。

    def reverseBetween(self, head: ListNode, m: int, n: int) -> ListNode:
        dummy = ListNode(0) #创建一个哨兵节点
        dummy.next = head   #哨兵节点下一项指向Head
        rhead = dummy     #再来一个指针指向哨兵节点
        for i in range(m-1):   # 前m-1个不需要反转
            rhead = rhead.next   
        cur  = rhead.next  #cur为反转的起始点       这里为 2 
        tail = rhead.next  #tail记录下这个起始点，便于到时候拼接  这里为2 
        pre = None       #与反转链表相同
        ntx = None
        for i in range(n-m+1):
            ntx = cur.next
            cur.next = pre
            pre = cur
            cur = ntx     
        rhead.next = pre     #pre此时是4；rhead是1 ，1 ->4
        tail.next = cur      #tail是2 ，2 -> 5
        return dummy.next    #dummy.next 就是 1 4 3 2 5

每k个反转一次：看这个