揭秘剑指 Offer 25：巧妙合并排序链表，重识链表奥秘

2024-01-03 18:48:46

引言：算法之美，链表的精髓

算法，计算机科学的瑰宝，它宛如魔术师，将晦涩难懂的数学概念幻化成优雅高效的代码，令人叹为观止。在算法的世界里，链表，这种古老而强大的数据结构，以其灵活多变的特性，成为众多算法题中的常客。而剑指 Offer 25：合并两个排序链表，正是探索链表精髓的经典之作。

题目简述：有序链表的完美融合

剑指 Offer 25 题目看似简单，却蕴含着深刻的算法思想。它要求我们合并两个递增排序的链表，使新链表中的节点仍然是递增排序的。表面上看，这似乎是一道简单的排序题，但实际上，它涉及到对链表结构的深刻理解和算法策略的灵活运用。

递归与迭代：两种解法，殊途同归

解决剑指 Offer 25，我们可以采用两种不同的算法策略：递归和迭代。递归，一种自顶向下的分解策略，将问题不断分解成更小的子问题，直至可以轻松解决，再逐层向上返回结果。而迭代，则是一种自底向上的构建策略，从问题最基本的部分开始，逐步累积构建出最终的解决方案。

递归解法：优雅的分治之道

递归解法，如同一场优雅的分治盛宴。它将合并两个链表的问题分解成两个更小的子问题：合并两个子链表，并将合并后的子链表与另一个链表合并。如此递归下去，直至两个链表都为空，最终得到合并后的有序链表。

def merge_two_lists_recursive(l1, l2):
    # 递归终止条件：两个链表都为空
    if not l1 and not l2:
        return None

    # 如果 l1 为空，则直接返回 l2
    if not l1:
        return l2

    # 如果 l2 为空，则直接返回 l1
    if not l2:
        return l1

    # 如果 l1 的值小于等于 l2 的值，则将 l1 的节点加入到合并后的链表中
    if l1.val <= l2.val:
        merged_head = l1
        merged_head.next = merge_two_lists_recursive(l1.next, l2)
    # 否则，将 l2 的节点加入到合并后的链表中
    else:
        merged_head = l2
        merged_head.next = merge_two_lists_recursive(l1, l2.next)

    return merged_head

迭代解法：稳扎稳打的构建

迭代解法，宛如一场稳扎稳打的建设工程。它从两个链表的头部开始，逐个比较节点的值，将较小的节点加入到合并后的链表中，同时将指针移动到下一个节点。如此循环往复，直至两个链表都为空，最终得到合并后的有序链表。

def merge_two_lists_iterative(l1, l2):
    # 创建一个哑结点作为合并后链表的头结点
    dummy = ListNode(0)

    # 指针指向哑结点
    current = dummy

    # 循环比较两个链表的节点
    while l1 and l2:
        # 如果 l1 的值小于等于 l2 的值，则将 l1 的节点加入到合并后的链表中
        if l1.val <= l2.val:
            current.next = l1
            l1 = l1.next
        # 否则，将 l2 的节点加入到合并后的链表中
        else:
            current.next = l2
            l2 = l2.next

        # 指针移动到下一个节点
        current = current.next

    # 将剩余的节点加入到合并后的链表中
    if l1:
        current.next = l1
    if l2:
        current.next = l2

    # 返回合并后链表的头结点
    return dummy.next

时间复杂度与空间复杂度：效率之辨

递归解法和迭代解法的時間複雜度都為 O(n+m)，其中 n 和 m 分別爲兩個鏈表的長度。

递归解法的空间复杂度取决于调用的栈帧数量，在最坏的情况下，递归解法需要 O(n+m) 的空间复杂度。而迭代解法只需要一个额外的节点来保存合并后的链表，因此其空间复杂度为 O(1)。

进阶挑战：尾递归优化

值得一提的是，递归解法还可以通过尾递归优化来进一步提高效率。尾递归优化是一种将递归调用放在函数的末尾的优化技术，它可以消除递归调用所带来的额外的栈帧开销，从而提高运行效率。

def merge_two_lists_tail_recursive(l1, l2):
    def merge_helper(l1, l2, merged_head):
        # 递归终止条件：兩個鏈表都爲空
        if not l1 and not l2:
            return merged_head

        # 如果 l1 爲空，則直接返回 l2
        if not l1:
            return l2

        # 如果 l2 爲空，則直接返回 l1
        if not l2:
            return l1

        # 如果 l1 的值小於等於 l2 的值，則將 l1 的節點加入到合併後的鏈表中
        if l1.val <= l2.val:
            merged_head.next = l1
            return merge_helper(l1.next, l2, merged_head.next)
        # 否則，將 l2 的節點加入到合併後的鏈表中
        else:
            merged_head.next = l2
            return merge_helper(l1, l2.next, merged_head.next)

    return merge_helper(l1, l2, ListNode(0))