LeetCode148. Sort List

Sort a linked list in O(n log n) time using constant space complexity.

Example 1:

Input: 4->2->1->3
Output: 1->2->3->4

Example 2:

 

Input: -1->5->3->4->0
Output: -1->0->3->4->5

 

---

 其实我也没弄明白为啥一定要用归并排序.

归并排序是一种时间复杂度为O(nlogn)(原始排序好坏都不影响),空间复杂度为O(n)的稳定排序,属于分治法的典型应用.

算法思路:

两个函数:一个函数是从链表中间断开,一个算法是将两个链表合在一起,递归调用.

需要注意的是断开点是在slow的前一个点,断开后要记得写上pre.next=None.

另一个是在合成两个链表时,可能最后一个为空一个仍有ListNode,记得要添加在合成链表的最后.

class Solution(object):
    def sortList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if not head or not head.next: return head
        fast = slow = head
        while fast and fast.next:
            pre = slow
            slow = slow.next
            fast = fast.next.next
        pre.next = None
        return self.merge(self.sortList(head), self.sortList(slow))
    
    
    def merge(self, left, right):
        
        dummy = p = ListNode(0)
        
        while left and right:
            if left.val < right.val:
                p.next = left
                p = p.next
                left = left.next
            else:
                p.next = right
                p = p.next
                right = right.next
            if left:
                p.next = left
            if right:
                p.next = right
        
        return dummy.next