Python中链表排序

链表是数据结构中常用的一种，但是由于它的存储方式和其它数据结构的差异，所以排序也和其它数据结构有所不同。

以下是一些对链表排序的方法以及代码：

冒泡排序（Bubble Sort）

冒泡排序是最简单的排序算法，其基本思想是比较相邻的元素，如果前一个比后一个大，就交换它们两个。经过一轮的比较，最大的元素就会沉到最底端，然后再从最开始的元素开始继续比较，依次类推，直到排序完成。

def bubble_sort(head):
    if not head or not head.next:
        return head
    
    dummy = ListNode(None)
    dummy.next = head
    
    end = None
    while end != dummy.next:
        cur = dummy.next
        while cur.next != end:
            if cur.val > cur.next.val:
                cur.val, cur.next.val = cur.next.val, cur.val
            cur = cur.next
        end = cur
    
    return dummy.next

归并排序（Merge Sort）

归并排序是一种分治（Divide-and-Conquer）算法，它将原始数据分为更小的同样类型的子问题，然后递归地解决每个子问题，最后合并子问题的解以获得原始问题的解。归并排序的核心思想是分治。

def merge_sort(head):
    if not head or not head.next:
        return head
    
    def merge(l1, l2):
        dummy = ListNode(None)
        cur = dummy
        
        while l1 and l2:
            if l1.val < l2.val:
                cur.next = l1
                l1 = l1.next
            else:
                cur.next = l2
                l2 = l2.next
            cur = cur.next
        
        if l1:
            cur.next = l1
        
        if l2:
            cur.next = l2
        
        return dummy.next
    
    slow, fast = head, head.next
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
    
    mid, slow.next = slow.next, None
    
    left, right = merge_sort(head), merge_sort(mid)
    
    return merge(left, right)

快速排序（Quick Sort）

快速排序是一种分治算法，它通过挖掘数据的潜在比较性质，在数据中选择一个"关键值"，并将数据划分为两个子序列：小于"关键值"的值和大于"关键值"的值。重复这个过程直到子序列不可分。

def quick_sort(head):
    if not head or not head.next:
        return head
    
    pivot, cur = head.val, head.next
    left, right = ListNode(None), ListNode(None)
    
    lcur, rcur = left, right
    
    while cur:
        if cur.val < pivot:
            lcur.next = cur
            lcur = lcur.next
        else:
            rcur.next = cur
            rcur = rcur.next
        cur = cur.next
    
    lcur.next, rcur.next = None, None
    
    left = quick_sort(left.next)
    right = quick_sort(right.next)
    
    dummy = ListNode(None)
    cur = dummy
    
    cur.next = left
    while cur.next:
        cur = cur.next
    cur.next = ListNode(pivot)
    
    cur.next.next = right
    
    return dummy.next

以上是一些链表排序的方法和代码片段。每个方法的时间复杂度都是 $O(n \log n)$ ，但是实际上归并排序的常数因子要比快速排序和冒泡排序小，因此效率更高。