归并排序非常适合在链表上应用，相比数组排序有独特优势。这是因为链表的节点分散存储，不需要像数组那样为合并操作分配连续内存，且拆分链表也无需额外空间。
一、链表归并排序的优势
- 空间效率更高 ：不需要像数组排序那样分配
O(n)的临时数组，仅需O(log n)的递归栈空间（非递归实现可优化至O(1)）。 - 拆分操作简单 ：通过快慢指针可在
O(n)时间内找到链表中点，无需计算索引。 - 合并操作自然：链表的节点指针调整比数组元素移动更高效（避免大规模数据复制）。
二、核心步骤（分治思想）
-
拆分（Divide） ： 用快慢指针找到链表中点，将链表分成左右两部分，递归拆分至每个子链表只剩1个节点（天然有序）。
-
合并（Merge） ： 将两个有序子链表合并为一个新的有序链表（通过调整节点
next指针实现）。
三、完整代码实现（Python）
包含链表节点定义、排序主函数、找中点函数、合并函数，以及测试验证逻辑：
ini
# 1. 定义单链表节点类
class ListNode:
def __init__(self, val=0, next=None):
self.val = val # 节点值
self.next = next # 指向下一节点的指针
# 2. 归并排序主函数：接收链表头节点，返回排序后的新链表头节点
def merge_sort(head):
# 基线条件：空链表 或 只有一个节点的链表，无需排序
if not head or not head.next:
return head
# 步骤1：拆分链表（先找中点，再断开）
mid_node = find_middle(head) # 找到左半部分的尾节点（中点前一个节点）
left_head = head # 左子链表头节点
right_head = mid_node.next # 右子链表头节点
mid_node.next = None # 断开左、右子链表，避免递归时互相干扰
# 递归拆分左、右子链表，直到每个子链表只有1个节点
sorted_left = merge_sort(left_head)
sorted_right = merge_sort(right_head)
# 步骤2：合并两个有序子链表
return merge(sorted_left, sorted_right)
# 3. 辅助函数：找链表中点（快慢指针法）
def find_middle(head):
if not head:
return head
slow = head # 慢指针：每次走1步
fast = head.next # 快指针：每次走2步（起点错开，确保拆分后左≤右，避免栈溢出）
# 当快指针无法再走2步时，慢指针停在左半部分尾节点
while fast and fast.next:
slow = slow.next
fast = fast.next.next
return slow
# 4. 辅助函数：合并两个有序链表
def merge(l1, l2):
# 虚拟头节点（dummy node）：简化边界处理（无需判断l1/l2是否为空）
dummy = ListNode(0)
current = dummy # 用于遍历拼接的指针
# 双指针遍历两个有序链表，按值从小到大拼接
while l1 and l2:
if l1.val <= l2.val: # 用<=保证排序稳定性（相等元素保留原顺序）
current.next = l1
l1 = l1.next # l1指针后移
else:
current.next = l2
l2 = l2.next # l2指针后移
current = current.next # 拼接指针后移
# 拼接剩余节点（其中一个链表已遍历完，直接接另一个的剩余部分）
current.next = l1 if l1 else l2
return dummy.next # 真实头节点是虚拟头节点的下一个
# 5. 测试：构建链表并验证排序结果
def print_linked_list(head):
"""辅助函数：打印链表（便于验证）"""
result = []
while head:
result.append(str(head.val))
head = head.next
print(" -> ".join(result))
# 构建测试链表：4 -> 2 -> 1 -> 3
node4 = ListNode(4)
node2 = ListNode(2)
node1 = ListNode(1)
node3 = ListNode(3)
node4.next = node2
node2.next = node1
node1.next = node3
# 排序前
print("排序前链表：", end=" ")
print_linked_list(node4) # 输出：4 -> 2 -> 1 -> 3
# 执行排序
sorted_head = merge_sort(node4)
# 排序后
print("排序后链表：", end=" ")
print_linked_list(sorted_head) # 输出：1 -> 2 -> 3 -> 4四、关键解析
- 找中点（
find_middle）： 快慢指针法中，快指针速度是慢指针的2倍。当快指针到达尾部时，慢指针恰好位于链表中点（左半部分的最后一个节点），确保拆分后左右两部分长度均衡。 - 合并逻辑（
merge） ： 通过虚拟头节点（dummy）简化链表拼接操作，无需单独处理头节点为空的情况。双指针比较节点值，按从小到大的顺序调整next指针，最后拼接剩余节点。 - 时间与空间复杂度 ： - 时间复杂度：
O(n log n)（拆分log n层，每层合并n个节点）。 - 空间复杂度：O(log n)（递归调用栈的深度），若用迭代实现可优化至O(1)。
五、 与数组归并排序的对比强化
为更直观体现链表归并排序的优势，可通过表格对比核心差异：
| 对比维度 | 数组归并排序 | 链表归并排序 |
|---|---|---|
| 空间复杂度 | O (n)（需临时数组存合并结果） | O (log n)（仅递归栈，可优化至 O (1)） |
| 拆分方式 | 按索引计算中点（O (1)） | 快慢指针找中点（O (n)） |
| 合并操作核心 | 元素复制（大规模移动，低效） | 指针调整（无数据移动，高效） |
| 内存连续性依赖 | 依赖连续内存（否则无法随机访问） | 不依赖（节点分散存储也可） |
六、适用场景
链表归并排序适合对大型链表 或频繁插入删除的动态链表 进行排序，尤其在Java的LinkedList、Python的链表实现等数据结构中应用广泛。由于其稳定性（相等元素保持原顺序），也常用于需要稳定排序的场景。
通过该对比可进一步理解：链表的非连续存储特性，恰好规避了数组归并排序的空间与复制开销，因此归并排序成为链表排序的 "最优解" 之一。