算法：间隔重排序链表Reorder List

题目

143. Reorder List

Given a singly linked list L: L0→L1→…→Ln-1→Ln,
reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→…

You may not modify the values in the list’s nodes, only nodes itself may be changed.

Example 1:

Given 1->2->3->4, reorder it to 1->4->2->3.

Example 2:

Given 1->2->3->4->5, reorder it to 1->5->2->4->3.

解题思路

举个具体例子：1->2->3->4->5->6

1. 先找出一半的位置，用快慢两个指针可以找出。返回前半部分1->2->3->null，和后半部分链表4->5->6；
2. 翻转后半部分链表6->5->4；
3. 逐个合并前半部分链表，和翻转后的后半部分链表

# https://leetcode.com/problems/reorder-list/
# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
class Solution:
    def reorderList(self, head: ListNode) -> None:
        """
        Do not return anything, modify head in-place instead.
        """
        if not head or not head.next:
            return

        halfHead, middle = self._splitList(head)
        reverse = self._reverseList(middle)
        head = self._mergeLists(halfHead, reverse)

    # Splits in place a list in two halves, the first half is --> in size than the second.
    # @return A tuple containing the heads of the two halves
    def _splitList(self, head: ListNode) -> (ListNode, ListNode):
        slow, fast = head, head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next

        middle = slow.next
        slow.next = None

        return head, middle

    # Reverses in place a list.
    # @return Returns the head of the new reversed list
    def _reverseList(self, head: ListNode) -> ListNode:
        last = None
        currentNode = head

        while currentNode:
            nextNode = currentNode.next
            currentNode.next = last
            last = currentNode
            currentNode = nextNode

        return last

    # Merges in place two lists
    # @return The newly merged list.
    def _mergeLists(self, a: ListNode, b: ListNode) -> ListNode:
        tail = a
        head = a

        a = a.next
        while b:
            tail.next = b
            tail = tail.next
            b = b.next
            if a:
                a, b = b, a

        return head