Programa C 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 proporciona 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 modo que todos los Nodes del primer nivel estén primero, luego los Nodes del segundo nivel, y así sucesivamente.
Cada Node es una estructura C con la siguiente definición.

struct List
{
    int data;
    struct List *next;
    struct List *child;
};

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 "cur" pointer, which will point to head of the first level of the list
2) Take "tail" pointer, which will point to end of the first level of the list
3) Repeat the below procedure while "curr" is not NULL.
    I) if 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 new child list and update "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. 

// Program to flatten list with next 
// and child pointers
#include <stdio.h>
#include <stdlib.h>
  
// Macro to find number of elements 
// in array
#define SIZE(arr) (sizeof(arr)/
                   sizeof(arr[0]))
  
// A linked list node has data, 
// next pointer and child pointer
struct Node
{
    int data;
    struct Node *next;
    struct Node *child;
};
  
// 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
struct Node *createList(int *arr, int n)
{
    struct Node *head = NULL;
    struct Node *p;
  
    int i;
    for (i = 0; i < n; ++i) 
    {
        if (head == NULL)
            head = p = (struct Node *)malloc(sizeof(*p));
        else 
        {
            p->next = (struct Node *)malloc(sizeof(*p));
            p = p->next;
        }
        p->data = arr[i];
        p->next = p->child = NULL;
    }
    return head;
}
  
// A utility function to print all nodes 
// of a linked list
void printList(struct Node *head)
{
    while (head != NULL) 
    {
        printf("%d ", head->data);
        head = head->next;
    }
    printf("");
}
  
// This function creates the input list.  
// The created list is same as shown in 
// the above figure
struct Node *createList(void)
{
    int arr1[] = {10, 5, 12, 7, 11};
    int arr2[] = {4, 20, 13};
    int arr3[] = {17, 6};
    int arr4[] = {9, 8};
    int arr5[] = {19, 15};
    int arr6[] = {2};
    int arr7[] = {16};
    int arr8[] = {3};
  
    // Create 8 linked lists 
    struct Node *head1 = createList(arr1, 
                                    SIZE(arr1));
    struct Node *head2 = createList(arr2, 
                                    SIZE(arr2));
    struct Node *head3 = createList(arr3, 
                                    SIZE(arr3));
    struct Node *head4 = createList(arr4, 
                                    SIZE(arr4));
    struct Node *head5 = createList(arr5, 
                                    SIZE(arr5));
    struct Node *head6 = createList(arr6, 
                                    SIZE(arr6));
    struct Node *head7 = createList(arr7, 
                                    SIZE(arr7));
    struct Node *head8 = createList(arr8, 
                                    SIZE(arr8));
  
    // 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(struct Node *head)
{
    // Base case
    if (head == NULL)
       return;
  
    struct Node *tmp;
  
    /* Find tail node of first level 
       linked list */
    struct Node *tail = head;
    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
    struct Node *cur = head;
    while (cur != tail)
    {
        // If current node has a child
        if (cur->child)
        {
            // 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)
                tmp = tmp->next;
            tail = tmp;
        }
  
        // Change current node
        cur = cur->next;
    }
}
  
// Driver code
int main(void)
{
    struct Node *head = NULL;
    head = createList();
    flattenList(head);
    printList(head);
    return 0;
}

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.