python单链表如何排序

Python单链表的排序可以通过多种方式实现，包括选择排序、插入排序和归并排序等算法。使用归并排序是单链表排序的最佳选择，因为归并排序具有稳定性和O(n log n)的时间复杂度。

在选择排序中，我们逐步选择未排序部分的最小（或最大）元素，并将其放在已排序部分的末尾。归并排序是另一种更为高效的方法，尤其适用于单链表，因为它不需要随机访问元素，只需处理相邻元素。归并排序的基本思想是将链表分成两个子链表，对每个子链表进行排序，然后将排序后的子链表合并成一个有序链表。归并排序在链表的场景下表现良好，因为分割链表和合并链表时，只需要操作指针，不需要额外的空间开销。

一、单链表的基本操作

在了解如何对单链表进行排序之前，我们首先需要了解单链表的基本结构和操作。单链表是由一系列节点组成的线性结构，每个节点包含一个数据域和一个指向下一个节点的指针。常见的操作包括创建链表、遍历链表、插入节点、删除节点等。

1. 创建链表

创建单链表需要定义一个节点类，每个节点包含数据和指向下一个节点的指针。可以通过迭代的方式或者递归的方式初始化链表。

class ListNode:
    def __init__(self, value=0, next=None):
        self.value = value
        self.next = next
def create_linked_list(values):
    if not values:
        return None
    head = ListNode(values[0])
    current = head
    for value in values[1:]:
        current.next = ListNode(value)
        current = current.next
    return head

2. 遍历链表

遍历链表就是从头节点开始，依次访问每一个节点，直到链表的末尾。

def traverse_linked_list(head):
    current = head
    while current:
        print(current.value)
        current = current.next

二、选择排序

选择排序是一种简单直观的排序算法。在单链表上实现选择排序的步骤如下：

从未排序部分选择最小的元素。
将这个元素放在已排序部分的末尾。
重复上述步骤，直到整个链表排序完成。

1. 选择排序实现

在单链表上实现选择排序需要遍历链表多次，时间复杂度为O(n^2)。

def selection_sort_linked_list(head):
    sorted_tail = None
    while head:
        prev_min = None
        min_node = head
        current = head
        prev = None
        while current:
            if current.value < min_node.value:
                prev_min = prev
                min_node = current
            prev = current
            current = current.next
        if prev_min:
            prev_min.next = min_node.next
        else:
            head = min_node.next
        min_node.next = sorted_tail
        sorted_tail = min_node
    return sorted_tail

三、插入排序

插入排序是另一个简单的排序算法，适用于较小的数据集。它的基本思想是将链表分成已排序和未排序两部分，逐个将未排序部分的元素插入到已排序部分的适当位置。

1. 插入排序实现

插入排序在链表上的时间复杂度为O(n^2)，但由于其简单性，常用于小规模数据的排序。

def insertion_sort_linked_list(head):
    dummy = ListNode(0)
    current = head
    while current:
        prev = dummy
        while prev.next and prev.next.value < current.value:
            prev = prev.next
        next_node = current.next
        current.next = prev.next
        prev.next = current
        current = next_node
    return dummy.next

四、归并排序

归并排序是一种高效的排序算法，具有O(n log n)的时间复杂度。它的基本思想是将链表分成两个子链表，分别进行排序，然后合并。

1. 归并排序实现

归并排序需要一个辅助函数来合并两个有序链表。

def merge_sorted_lists(l1, l2):
    dummy = ListNode(0)
    current = dummy
    while l1 and l2:
        if l1.value < l2.value:
            current.next = l1
            l1 = l1.next
        else:
            current.next = l2
            l2 = l2.next
        current = current.next
    current.next = l1 if l1 else l2
    return dummy.next

接下来，实现归并排序的主函数：

def merge_sort_linked_list(head):
    if not head or not head.next:
        return head
    # Find the middle of the list
    slow, fast = head, head.next
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
    mid = slow.next
    slow.next = None
    left = merge_sort_linked_list(head)
    right = merge_sort_linked_list(mid)
    return merge_sorted_lists(left, right)