LeetCode430: Lista aplanada multinivel doblemente enlazada

1. Descripción del título

    En una lista multinivel doblemente enlazada, además del puntero al siguiente nodo y al nodo anterior, también tiene un puntero de lista subenlazada, que puede apuntar a una lista separada doblemente enlazada. Estas sublistas también pueden tener uno o más de sus propios hijos, y así sucesivamente, para generar una estructura de datos de varios niveles, como se muestra en el siguiente ejemplo.

    Darle el nodo principal en el primer nivel de la lista. Aplanar la lista para que todos los nodos aparezcan en la lista de doble enlace de un solo nivel.

Ejemplo 1:

输入：head = [1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]
输出：[1,2,3,7,8,11,12,9,10,4,5,6]

Explicación:

    La lista de varios niveles ingresada se muestra a continuación:

La lista vinculada después del aplanamiento es la siguiente:

Ejemplo 2:

输入：head = [1,2,null,3]
输出：[1,3,2]
解释：

输入的多级列表如下图所示：

  1---2---NULL
  |
  3---NULL

Ejemplo 3:

输入：head = []
输出：[]

¿Cómo representar la lista enlazada de varios niveles en el caso de prueba?

Con el ejemplo 1 como ejemplo:

 1---2---3---4---5---6--NULL
         |
         7---8---9---10--NULL
             |
             11--12--NULL

Después de serializar cada uno de estos niveles:

[1,2,3,4,5,6,null]
[7,8,9,10,null]
[11,12,null]

Para serializar cada nivel juntos, necesitamos agregar un elemento con un valor de nulo en cada nivel para indicar que ningún nodo está conectado al nodo padre del nivel anterior.

[1,2,3,4,5,6,null]
[null,null,7,8,9,10,null]
[null,11,12,null]

Combine todos los resultados serializados y elimine el nulo al final.

[1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]

rápido:

• El número de nodos no supera los 1000
• 1 <= Node.val <= 10 ^ 5

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* prev;
    Node* next;
    Node* child;
};
*/

class Solution {
    
    
public:
    Node* flatten(Node* head) {
    
    
        //to do
    }
};

Dos ideas para resolver problemas

1. Para cada nodo, primero use un puntero doble: p, pNext = p-> next, cuando p-> child está vacío, el puntero p se mueve hacia atrás.

2. Cuando p-> niño no está vacío

   2.1 Conecte py p-> child en una estructura de lista doblemente enlazada, y establezca p-> child en vacío;

       Node* pChild=p->child;
       p->next=pChild;
       pChild->prev=p;
       p->child=nullptr;
   

   2.2 Encuentre el nodo final de la cadena secundaria p-> child y conéctelo con pNext para formar una estructura de lista doblemente vinculada

       Node* tail=pChild;
       while(tail->next!=nullptr){
         
         
       	tail=tail->next;
       }
       tail->next=pNext;
       if(pNext!=nullptr)
       	pNext->prev=tail;  
   

    

    

    

Las tres imágenes anteriores son el caso de eliminar una subcadena.

Tres, mi codigo

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* prev;
    Node* next;
    Node* child;
};
*/
class Solution {
    
    
public:
    Node* flatten(Node* head) {
    
    
        if(head==nullptr)
            return head;
        Node* p=head;
        while(p!=nullptr){
    
    
            Node* pNext=p->next;
            if(p->child!=nullptr){
    
    
                Node* pChild=p->child;
                p->next=pChild;
                pChild->prev=p;
                p->child=nullptr;
                Node* tail=pChild;
                while(tail->next!=nullptr){
    
    
                    tail=tail->next;
                }
                tail->next=pNext;
                if(pNext!=nullptr)
                    pNext->prev=tail;                
            }
            p=p->next;
        }
        return head;
    }
};