链表排序 -- 插入和归并

本文介绍两种链表排序的方法，归并排序和插入排序，时间复杂度和空间复杂度等价于数组排序，
关于数组排序的时空复杂度，参考：数组排序复杂度

leetcode题目：
148. 排序链表

class SortLinkedArray:
    """
    148. 排序链表
    https://leetcode.cn/problems/sort-list/description/?envType=study-plan-v2&envId=top-100-liked
    """
    def solution1(self, head: Optional[ListNode]) -> Optional[ListNode]:
        """
        归并排序，自顶向下
        时间复杂度：O(nlogn)
        空间复杂度：O(n)
        :param head:
        :return:
        """
        return self.sortFunc(head, None)

    def sortFunc(self, head: ListNode, tail: Optional[ListNode]) -> ListNode:
        """
        排序 [head..tail)
        :param head:
        :param tail:
        :return:
        """
        if not head:
            return head

        # base case
        if head.next == tail:
            head.next = None
            return head

        slow, fast = head, head
        while fast != tail:
            slow = slow.next
            fast = fast.next
            if fast != tail:
                fast = fast.next
        mid = slow
        return self.merge(self.sortFunc(head, mid), self.sortFunc(mid, tail))

    # 合并两个有序链表
    def merge(self, head1: ListNode, head2: ListNode) -> ListNode:
        dummy = ListNode(0)
        p, p1, p2 = dummy, head1, head2
        while p1 and p2:
            if p1.val < p2.val:
                p.next = p1
                p1 = p1.next
            else:
                p.next = p2
                p2 = p2.next
            p = p.next

        if p1:
            p.next = p1
        else:
            p.next = p2

        return p.next

    def solution2(self, head: Optional[ListNode]) -> Optional[ListNode]:
        """
        归并排序，自底向上
        时间复杂度：O(nlogn)
        空间复杂度：O(1)
        :param head:
        :return:
        """
        if not head:
            return head

        length = 0
        node = head
        while node:
            length += 1
            node = node.next

        dummyHead = ListNode(0, head)
        subLength = 1
        while subLength < length:
            prev, cur = dummyHead, dummyHead.next
            while cur:
                head1 = cur
                for i in range(1, subLength):
                    if cur.next:
                        cur = cur.next
                    else:
                        break

                head2 = cur.next
                cur.next = None
                cur = head2

                for i in range(1, subLength):
                    if cur and cur.next:
                        cur = cur.next
                    else:
                        break

                # 下一个待合并的节点头
                succ = None
                if cur:
                    succ = cur.next
                    cur.next = None

                merged = self.merge(head1, head2)
                prev.next = merged
                while prev.next:
                    prev = prev.next

                cur = succ

            subLength <<= 1

        return dummyHead.next

    def solution3(self, head: Optional[ListNode]) -> Optional[ListNode]:
        """
        插入排序
        时间复杂度：O(n**2)
        空间复杂度：O(1)
        :param head:
        :return:
        """
        if not head:
            return head

        dummy = ListNode(0)
        dummy.next = head
        # lastSorted 为链表的已排序部分的最后一个节点
        lastSorted = head
        curr = head.next
        
        while curr:
            if lastSorted.val <= curr.val:
                lastSorted = lastSorted.next
            else:
                prev = dummy
                while prev.next.val <= curr.val:
                    prev = prev.next
                
                lastSorted.next = curr.next
                curr.next = prev.next
                prev.next = curr
            
            curr = lastSorted.next
        
        return dummy.next