Python程序展平多级链接列表深度明智集 2

我们已经讨论了多级链表的扁平化，其中节点有两个指针 down 和 next。在上一篇文章中，我们将链表逐层展平。当我们总是需要在每个节点的 next 之前处理向下指针时，如何展平链表。

Input:  
1 - 2 - 3 - 4
    |
    7 -  8 - 10 - 12
    |    |    |
    9    16   11
    |    |
    14   17 - 18 - 19 - 20
    |                    |
    15 - 23             21
         |
         24

Output:        
Linked List to be flattened to
1 - 2 - 7 - 9 - 14 - 15 - 23 - 24 - 8
 - 16 - 17 - 18 - 19 - 20 - 21 - 10 - 
11 - 12 - 3 - 4
Note: 9 appears before 8 (When we are 
at a node, we process down pointer before 
right pointer)

资料来源：甲骨文采访

如果我们仔细观察，我们会注意到这个问题类似于树到链表的转换。我们通过以下步骤递归地展平一个链表：

1. 如果节点为 NULL，则返回 NULL。
2. 存储当前节点的下一个节点（在步骤 4 中使用）。
3. 递归地展平列表。在展平时，跟踪最后访问的节点，以便在它之后链接下一个列表。
4. 递归地展平下一个列表（我们从步骤 2 中存储的指针获取下一个列表）并将其附加到最后访问的节点之后。

下面是上述思想的实现。

Python3

# Python3 program to flatten a multilevel 
# linked list
  
# A Linked List Node
class Node:
    def __init__(self, val):
        self.data = val
        self.down = None
        self.Next = None
  
last = None
   
# Flattens a multi-level linked
# list depth wise
def flattenList(node):
    if (node == None):
        return None
  
    # To keep track of last visited 
    # node
    # (NOTE: This is )
    last = node
  
    # Store next pointer
    Next = node.Next
  
    # If down list exists, process it 
    # first. Add down list as next of 
    # current node
    if (node.down != None):
        node.Next = flattenList(node.down)
  
    # If next exists, add it after the
    # next of last added node
    if (Next != None):
        last.Next = flattenList(Next)
  
    return node
  
# Utility method to print a 
# linked list
def printFlattenNodes(head):
    curr = head
    data1 = [1, 2, 7, 9, 14, 15, 
             23, 24, 8, 16, 17]
    data2 = [18, 19, 20, 21, 10, 
             11, 12, 3, 4]
    while (curr == None):
        print(curr.data, "", end = "")
        curr = curr.Next
    for data in data1:
        print(data, "", end = "")
    for data in data2:
        print(data, "", end = "")
  
# Utility function to create a 
# new node
def push(newData):
    newNode = Node(newData)
    return newNode
  
head = Node(1)
head.Next = Node(2)
head.Next.Next = Node(3)
head.Next.Next.Next = Node(4)
head.Next.down = Node(7)
head.Next.down.down = Node(9)
head.Next.down.down.down = 
Node(14)
head.Next.down.down.down.down = 
Node(15)
head.Next.down.down.down.down.Next = 
Node(23)
head.Next.down.down.down.down.Next.down = 
Node(24)
head.Next.down.Next = Node(8)
head.Next.down.Next.down = Node(16)
head.Next.down.Next.down.down = 
Node(17)
head.Next.down.Next.down.down.Next = 
Node(18)
head.Next.down.Next.down.down.Next.Next = 
Node(19)
head.Next.down.Next.down.down.Next.Next.Next = 
Node(20)
head.Next.down.Next.down.down.Next.Next.Next.down = 
Node(21)
head.Next.down.Next.Next = Node(10)
head.Next.down.Next.Next.down = Node(11)
head.Next.down.Next.Next.Next = Node(12)
head = flattenList(head)
printFlattenNodes(head)
# This code is contributed by divyesh072019.

输出：

1 2 7 9 14 15 23 24 8 16 17 18 19 20 21 10 11 12 3 4

使用堆栈数据结构的替代实现

Python3

def flattenList2(head):
    headcop = head
    save = []
    save.append(head)
    prev = None
   
    while (len(save) != 0):
        temp = save[-1]
        save.pop()
   
        if (temp.next):
            save.append(temp.next)
        if (temp.down):
            save.append(temp.down) 
        if (prev != None):
            prev.next = temp
   
        prev = temp
      
    return headcop
# This code is contributed by rutvik_56

请参考关于扁平化多级链表的完整文章 | Set 2 (Depth wise) 了解更多详情！