LeetCode #148 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)有堆排序、快速排序以及归并排序。此处选用归并排序。

归并排序主要分为两个部分：

（1）分治。将一个链表分成左右两段，分别进行排序之后再归并；

（2）归并。将左右链表从头到尾进行比较，从小到大排列成与原链表同等长度的链表。

话不多说，结合代码立见分晓。

【代码实现】

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def sortList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if not head or not head.next:
            return head
        
        dummy = ListNode(0) # 头指针
        dummy.next = head
        mid = rear = dummy

        # 找到中间节点（利用rear的移动速度为mid的两倍）
        while rear.next and rear.next.next:
            mid = mid.next
            rear = rear.next.next

        # 分治
        l2 = self.sortList(mid.next)
        mid.next = None
        l1 = self.sortList(dummy.next)
        return self.merge(l1, l2)

    
    # 归并
    def merge(self, l1, l2):
        if not l1:
            return l2
        if not l2:
            return l1
        
        dummy = ListNode(0) # 头指针
        p = dummy

        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

        if l1:
            p.next = l1
        else:               # 由于链表需要以None结尾，所以此处不能用elif l2:
            p.next = l2

        return dummy.next   

【总结回顾】

如果是对列表（list）类型进行排序，与自定义的链表相比，需要增加一个辅助列表来存储归并后的列表，所以空间复杂度为O(n)。而且在分治的标记以及归并的判断上还需要用到三个起点的索引（low），中点的索引（middle）以及终点的索引（high）。

代码如下：

# 对列表进行归并排序
class Solution:
    def sortList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        newhead = head[:]
        self.divide(head, newhead, 0, len(head) - 1)
        return head

    # 分治
    def divide(self, head, newhead, low, high):
        if low < high:
            middle = (low + high) // 2
            self.divide(head, newhead, low, middle)
            self.divide(head, newhead, middle + 1, high)
            self.merge(head, newhead, low, middle, high) # 前后两个子序列归并
    
    # 归并
    def merge(self, head, newhead, low, middle, high):
        i = low
        j = middle + 1
        k = low
        while i <= middle and j <= high:
            if head[i] <= head[j]:
                newhead[k] = head[i]
                i += 1
            else:
                newhead[k] = head[j]
                j += 1
            k += 1
        
        while i <= middle:
            newhead[k] = head[i]
            i += 1
            k += 1

        while j <= high:
            newhead[k] = head[j]
            j += 1
            k += 1
        
        # 修改原列表
        for n in range(0, len(head)):
            head[n] = newhead[n]
        # 不能够使用head = newhead[:]，这样是使用另一块存储空间，与先前的head不是同一个地址
        
'''
sol = Solution()
head = [4, 2, 1, 3]
newhead = sol.sortList(head)
print(newhead)
'''