链表的迭代归并排序

介绍

链表的迭代归并排序是一种对链表进行排序的算法。它通过将链表不断地拆分成较小的部分，对这些部分进行排序后再进行合并，最终得到一个有序的链表。相比于其他排序算法，链表的迭代归并排序具有稳定性、内存占用小等优点。

实现

链表的迭代归并排序是一种自底向上的排序方法。它的思路如下：

1. 将链表拆分成较小的部分，每部分的长度为1，即一个节点；
2. 对相邻的两部分进行合并，得到长度为2的有序链表；
3. 重复步骤2，将长度为2的有序链表合并，得到长度为4的有序链表；
4. 重复步骤3，直到所有部分都被合并成一个有序链表。

下面是链表的迭代归并排序的实现代码：

def merge(l1, l2):
    """
    合并两个有序链表
    """
    dummy = ListNode(0)  # 创建虚拟头节点
    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
    else:
        cur.next = l2
    return dummy.next


def sortList(head: ListNode) -> ListNode:
    if not head or not head.next:
        return head
    # 统计链表长度
    length = 0
    cur = head
    while cur:
        length += 1
        cur = cur.next
    # 循环拆分合并
    dummy = ListNode(0)
    dummy.next = head
    for i in range(1, length+1):
        pre = dummy
        cur = dummy.next
        while cur:
            left = cur
            right = cut(left, i)
            cur = cut(right, i)
            pre.next = merge(left, right)
            while pre.next:
                pre = pre.next
    return dummy.next


def cut(head, n):
    """
    将链表切割成长度为n的两部分，返回后半部分的头节点
    """
    if not head:
        return None
    for i in range(n-1):
        if not head.next:
            break
        head = head.next
    tail = head.next
    if tail:
        head.next = None
    return tail

性能分析

链表的迭代归并排序的时间复杂度为O(nlogn)，其中n是链表的长度。空间复杂度主要取决于递归或迭代的实现方式，一般为O(logn)或O(1)。

使用场景

链表的迭代归并排序适用于对链表进行排序的场景，特别是链表长度较大时。由于其稳定性和内存占用小的优点，常用于代码实现中。