Programa de Python para aplanar una lista enlazada de varios niveles – Part 1

Dada una lista enlazada donde, además del puntero siguiente, cada Node tiene un puntero secundario, que puede o no apuntar a una lista separada. Estas listas de elementos secundarios pueden tener uno o más elementos secundarios propios, y así sucesivamente, para producir una estructura de datos de varios niveles, como se muestra en la siguiente figura. Se le asigna el encabezado del primer nivel de la lista. Aplane la lista para que todos los Nodes aparezcan en una lista vinculada de un solo nivel. Debe aplanar la lista de forma que todos los Nodes del primer nivel queden primero, luego los Nodes del segundo nivel, y así sucesivamente.
Cada Node es una estructura C con la siguiente definición.

# A linked list node has data, 
# next pointer and child pointer 
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.child = None
          
        # This code contributed by umadevi9616

La lista anterior debe convertirse a 10->5->12->7->11->4->20->13->17->6->2->16->9->8->3 ->19->15

El problema dice claramente que necesitamos aplanar nivel por nivel. La idea de una solución es que comenzamos desde el primer nivel, procesamos todos los Nodes uno por uno, si un Node tiene un hijo, luego agregamos el hijo al final de la lista, de lo contrario, no hacemos nada. Después de procesar el primer nivel, todos los Nodes del siguiente nivel se agregarán después del primer nivel. Se sigue el mismo proceso para los Nodes adjuntos.

1) Take the "cur" pointer, which will point to the head 
        of the first level of the list
2) Take the "tail" pointer, which will point to the end of 
   the first level of the list
3) Repeat the below procedure while "curr" is not NULL.
    I) If the current node has a child then
    a) Append this new child list to the "tail"
        tail->next = cur->child
    b) Find the last node of the new child list and update 
       the "tail"
        tmp = cur->child;
        while (tmp->next != NULL)
            tmp = tmp->next;
        tail = tmp;
    II) Move to the next node. i.e. cur = cur->next

A continuación se muestra la implementación del algoritmo anterior. 

# Python3 Program to flatten list with
# next and child pointers 
  
# A linked list node has data, 
# next pointer and child pointer 
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
        self.child = None
  
# Return Node
def newNode(data):
    return Node(data) 
  
# The main function that flattens
# a multilevel linked list
def flattenlist(head):
      
    # Base case
    if not head:
        return
      
    # Find tail node of first level 
    # linked list
    temp = head
    while(temp.next != None):
        temp = temp.next
    currNode = head
      
    # One by one traverse through all 
    # nodes of first level linked list
    # till we reach the tail node 
    while(currNode != temp):
          
        # If current node has a child
        if(currNode.child):
              
            # then append the child
            # at the end of current list 
            temp.next = currNode.child
              
            # and update the tail to new 
            # last node 
            tmp = currNode.child
            while(tmp.next):
                tmp = tmp.next
            temp = tmp
              
        # Change current node 
        currNode = currNode.next
      
# A utility function to print 
# all nodes of a linked list 
def printList(head): 
    if not head: 
        return
    while(head): 
        print("{}".format(head.data), 
              end = " ") 
        head = head.next
  
# Driver code 
if __name__=='__main__': 
      
    # Child list of 13
    child13 = newNode(16)
    child13.child = newNode(3)
      
    # Child List of 10
    head1 = newNode(4)
    head1.next = newNode(20)
  
    # Child of 20 
    head1.next.child = newNode(2) 
    head1.next.next = newNode(13)
    head1.next.next.child = child13
      
    # Child of 9
    child9 = newNode(19)
    child9.next = newNode(15)
  
    # Child List of 17
    child17 = newNode(9)
    child17.next = newNode(8)
    child17.child = child9
  
    # Child List of 7
    head2 = newNode(17)
    head2.next = newNode(6)
    head2.child = child17
      
    # Main List
    head = newNode(10)
    head.child = head1
    head.next = newNode(5)
    head.next.next = newNode(12)
    head.next.next.next = newNode(7)
    head.next.next.next.child = head2
    head.next.next.next.next = newNode(11)
  
    flattenlist(head)
  
    print("Flattened list is: ", end = "") 
    printList(head)
# This code is contributed by 0_hero

Producción:

10 5 12 7 11 4 20 13 17 6 2 16 9 8 3 19 15

Complejidad de tiempo: dado que cada Node se visita como máximo dos veces, la complejidad de tiempo es O (n), donde n es el número de Nodes en una lista vinculada dada.

Consulte el artículo completo sobre Aplanar una lista vinculada de varios niveles para obtener más detalles.