Programa Java para aplanar una lista enlazada multinivel

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.

static class List
{
    public int data;
    public List next;
    public List child;
};
// This code is contributed by pratham76

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. 

// Java program to flatten linked list with 
// next and child pointers
class LinkedList 
{    
    static Node head;
      
    class Node 
    {        
        int data;
        Node next, child;
          
        Node(int d) 
        {
            data = d;
            next = child = null;
        }
    }
  
    // A utility function to create a linked list 
    // with n nodes. The data of nodes is taken 
    // from arr[].  All child pointers are set 
    // as NULL
    Node createList(int arr[], int n) 
    {
        Node node = null;
        Node p = null;
          
        int i;
        for (i = 0; i < n; ++i) 
        {
            if (node == null) 
            {
                node = p = new Node(arr[i]);
            } 
            else 
            {
                p.next = new Node(arr[i]);
                p = p.next;
            }
            p.next = p.child = null;
        }
        return node;
    }
  
    // A utility function to print all 
    // nodes of a linked list
    void printList(Node node) 
    {
        while (node != null) 
        {
            System.out.print(node.data + " ");
            node = node.next;
        }
        System.out.println("");
    }
      
    Node createList() 
    {
        int arr1[] = new int[]{10, 5, 
                               12, 7, 11};
        int arr2[] = new int[]{4, 20, 13};
        int arr3[] = new int[]{17, 6};
        int arr4[] = new int[]{9, 8};
        int arr5[] = new int[]{19, 15};
        int arr6[] = new int[]{2};
        int arr7[] = new int[]{16};
        int arr8[] = new int[]{3};
  
        // Create 8 linked lists 
        Node head1 = createList(arr1,  
                                arr1.length);
        Node head2 = createList(arr2, 
                                arr2.length);
        Node head3 = createList(arr3, 
                                arr3.length);
        Node head4 = createList(arr4, 
                                arr4.length);
        Node head5 = createList(arr5, 
                                arr5.length);
        Node head6 = createList(arr6, 
                                arr6.length);
        Node head7 = createList(arr7, 
                                arr7.length);
        Node head8 = createList(arr8, 
                                arr8.length);
  
        // Modify child pointers to create 
        // the list shown above 
        head1.child = head2;
        head1.next.next.next.child = head3;
        head3.child = head4;
        head4.child = head5;
        head2.next.child = head6;
        head2.next.next.child = head7;
        head7.child = head8;
  
        /* Return head pointer of first linked list.  
           Note that all nodes are reachable from 
           head1 */
        return head1;
    }
  
    /* The main function that flattens a multilevel 
       linked list */
    void flattenList(Node node) 
    {        
        // Base case
        if (node == null) 
        {
            return;
        }
          
        Node tmp = null;
  
        /* Find tail node of first level 
           linked list */
        Node tail = node;
        while (tail.next != null) 
        {
            tail = tail.next;
        }
  
        // One by one traverse through all nodes 
        // of first level linked list till we 
        // reach the tail node
        Node cur = node;
        while (cur != tail) 
        {
            // If current node has a child
            if (cur.child != null) 
            {
                // Then append the child at the 
                // end of current list
                tail.next = cur.child;
  
                // And update the tail to new 
                // last node
                tmp = cur.child;
                while (tmp.next != null) 
                {
                    tmp = tmp.next;
                }
                tail = tmp;
            }
  
            // Change current node
            cur = cur.next;
        }
    }
      
    // Driver code
    public static void main(String[] args) 
    {
        LinkedList list = new LinkedList();
        head = list.createList();
        list.flattenList(head);
        list.printList(head);
    }
}
// This code has been contributed by Mayank Jaiswal

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.