展平链表

在一些算法题中，会出现一个叫做展平链表的问题。展平链表的本质是将一个嵌套的链表（即一个节点可能有多个子节点，或者说多个链表可以组成一个总链表）转成一个单链表。例如，下面这个嵌套的链表：

1 -> 2 -> 3
      |
      v
     4 -> 5 -> 6
           |
           v
          7 -> 8

展开后应该得到这样的结果：

1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8

本文将介绍如何实现这个功能，并且会从递归、迭代两个角度来探讨不同的解法。

递归解法

递归是一种自我调用的方式来解决问题的方法。在展平链表中，我们可以使用递归的方式来解决。

对于每个节点，我们可以判断它是否有子节点。如果有，就对子节点进行递归调用，将其展平后的子链表插入到当前节点和下一个节点的之间。这个过程可以用下面的伪代码表示：

def flatten(node):
    if node is None:
        return None
    
    # 对子节点递归调用
    child = flatten(node.child)
    
    # 将展平后的子链表插入到当前节点和下一个节点的之间
    if child is not None:
        next_node = node.next
        node.next = child
        child.prev = node
        tail = find_tail(child)
        tail.next = next_node
        if next_node is not None:
            next_node.prev = tail
    
    # 对下一个节点进行递归调用
    flatten(node.next)
    
def find_tail(node):
    while node.next is not None:
        node = node.next
    return node

其中，node 是当前节点，node.child 是它的子节点（如果有），node.next 是它的下一个节点（如果有），node.prev 是它的前一个节点（如果有）。

此外，我们还需要实现一个辅助函数 find_tail，它用于在链表中找到最后一个节点。

迭代解法

通过迭代的方式，我们可以将递归转化成循环。

在迭代的解法中，关键是如何处理子节点。我们可以思考一下，如何将一个节点的子节点插入到它和它的下一个节点之间。观察一下上面的示意图，可以发现，我们需要取出子链表的最后一个节点，将它的下一个节点指向当前节点的下一个节点。

因此，迭代解法的代码可以写成下面这样：

def flatten(head):
    if head is None:
        return None
    
    node = head
    while node is not None:
        if node.child is not None:
            child = node.child

            # 找到子链表的最后一个节点
            while child.next is not None:
                child = child.next
                
            # 将子链表插入到当前节点和下一个节点之间
            next_node = node.next
            node.next = node.child
            node.child.prev = node
            child.next = next_node
            if next_node is not None:
                next_node.prev = child
                
            # 将子节点的引用设为 None
            node.child = None
            
        node = node.next

其中，head 是链表的头节点，node.child 是当前节点的子节点（如果有），node.next 是当前节点的下一个节点（如果有），node.prev 是当前节点的前一个节点（如果有）。同时，我们也需要注意处理好子节点的引用，避免出错。

总结

展平链表是一个经典的算法问题。在本文中，我们介绍了使用递归和迭代两种不同的方式来解决它。对于这两种方式，它们的时间复杂度都是 $O(n)$，其中 $n$ 是链表中节点的个数。但是，由于它们的实现方式不同，它们在空间复杂度和代码结构上有所不同。程序员可以根据实际任务和个人偏好来选择使用哪种方式。