leetcode 148 排序链表

给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。
输入：head = [4,2,1,3]
输出：[1,2,3,4]

插入排序的时间复杂度是 O（n2），这道题考虑时间复杂度更低的排序算法。题目的进阶问题要求达到 O(nlogn) 的时间复杂度和 O(1) 的空间复杂度，时间复杂度是 O(nlogn) 的排序算法包括归并排序、堆排序和快速排序，其中最适合链表的排序算法是归并排序。归并排序基于分治算法。最容易想到的实现方式是自顶向下的递归实现，考虑到递归调用的栈空间，自顶向下归并排序的空间复杂度是 O(logn)。如果要达到 O(1) 的空间复杂度，则需要使用自底向上的实现方式。

方法一：自顶向下归并排序
对链表自顶向下归并排序的过程如下。找到链表的中点，以中点为分界，将链表拆分成两个子链表。寻找链表的中点可以使用快慢指针的做法，快指针每次移动 2步，慢指针每次移动 1步，当快指针到达链表末尾时，慢指针指向的链表节点即为链表的中点, 注意如果节点为偶数一定要对半分，否则会陷入无限循环（比如有两个节点的时候）
对两个子链表分别排序。将两个排序后的子链表合并，得到完整的排序后的链表。
上述过程可以通过递归实现。递归的终止条件是链表为空或者链表只包含 1 个节点时，此时不需要对链表进行拆分和排序。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if (not head) or (not head.next):
            return head
        slow = head 
        fast = head
        while fast and fast.next:
            pre = slow 
            slow = slow.next
            fast = fast.next.next 
        pre.next = None
        left = self.sortList(head)
        right = self.sortList(slow)
        sorted = self.merge(left, right)
        return sorted
    
    def merge(self, left, right):
        i = left 
        j = right
        dummy = ListNode()
        cur = dummy
        while i and j:
            if i.val < j.val:
                cur.next = i
                i = i.next
            else:
                cur.next = j
                j = j.next
            cur = cur.next
        if i:
            cur.next = i 
        elif j:
            cur.next = j 
        else:
            cur.next = None
        return dummy.next

自底向上
设链表长度为n, 将链表拆分成若干个长度为 sub_num(初始为1) 的子链表（最后一个子链表的长度可以小于sub_num ），按照每两个子链表一组进行左右合并，合并后即可得到若干个长度为 2sub_num 的有序子链表（最后一个子链表的长度可以小于2sub_num ）。合并的时候，如果最后一个左子链表的长度小于sub_num，该左子链表必然已经是有序的。
将 sub_num的值加倍，重复上面步骤直到有序子链表的长度大于或等于 n，整个链表排序完毕。
空间复杂度O(1)，因为没有用到栈

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def sortList(self, head):
	    if (not head) or (not head.next):
	        return head
	
	    # 获取链表中节点的总数
	    n = 0
	    cur = head
	    while cur:
	        cur = cur.next
	        n += 1
	
	    sub_num = 1
	    dummy = ListNode(next=head)
	    while sub_num < n:
	        # 左右子链表合并后形成的新的有序子链表之间需要用pre来连接
	        # 对于第一个子链表来说，此时pre就是整个链表的dummy head
	        pre = dummy
	        cur = dummy.next
	        while cur:
	            # 左区间
	            left = cur
	            i = 0
	            while (i < sub_num - 1) and cur.next:
	                cur = cur.next
	                i += 1
	            # 此时cur对应的位置为左区间的右边界点，
	            # 右区间的开始节点为mid = cur.next
	            # 如果左子链表的长度小于sub_num，即mid=temp=cur.next=None，
	            # temp是用来存储下一个左子边界的开始位置的
	            temp = cur.next
	            mid = cur.next
	            # 打断链表
	            cur.next = None
	
	
	            # 右区间
	            # 如果左子链表长度小于sub_num, 此时cum=mid=None，循环不会执行
	            if mid:
	                i = 0
	                cur = mid
	                while (i < sub_num - 1) and cur.next:
	                    cur = cur.next
	                    i += 1
	                # 此时cur对应的位置为右区间的右边界点, 如果此时已经遍历结束则temp=cur.next=None
	                # temp是用来存储下一个左子边界的开始位置的
	                temp = cur.next
	                # 打断链表
	                cur.next = None
	
	
	            # 如果左子链表长度小于sub_num, 则mid=None
	            # 左子链表本身必定已经有序了，合并结果就是left直接返回
	            # 对于第一个合并后的有序子链表来说，pre就是整个链表的dummy head
	            # 需要用pre把dummy head重定向到第一个合并后的有序子链表的第一个节点, 这样dummy head是动态更新所指的
	            pre.next = self.merge(left, mid)
	            while pre.next:
	                pre = pre.next
	            # 此时pre指向合并后的链表的右边界点，下一次循环中它被用来指向合并后的链表
	            # 如果已经遍历结束，则temp = None, 也就是遍历结束，否则用temp恢复下一个左边界的开始点
	            cur = temp
	        sub_num *= 2
	    # dummy head是动态更新所指的，因此它所指的就是有序链表的最小值
	    return dummy.next
            
            
    def merge(self, left, right):
        i = left 
        j = right
        dummy = ListNode()
        cur = dummy
        while i and j:
            if i.val < j.val:
                cur.next = i
                i = i.next
            else:
                cur.next = j
                j = j.next
            cur = cur.next
        if i:
            cur.next = i 
        elif j:
            cur.next = j 
        else:
            cur.next = None
        return dummy.next