# Leetcode Flatten a Multilevel Doubly Linked List problem solution

In this Leetcode Flatten a Multilevel Doubly Linked List problem solution You are given a doubly linked list which in addition to the next and previous pointers, it could have a child pointer, which may or may not point to a separate doubly linked list. These child lists may have one or more children of their own, and so on, to produce a multilevel data structure, as shown in the example below.

Flatten the list so that all the nodes appear in a single-level, doubly linked list. You are given the head of the first level of the list.

## Problem solution in Python.

```class Solution:
def flatten(self, head: 'Node') -> 'Node':

def helper(head, stack=[]):
if not head: return head

node = head
while node:
if node.child:
if node.next: stack.append(node.next)
temp       = node.child
node.next  = temp
temp.prev  = node
node.child = None
elif not node.next and stack:
temp = stack.pop()
node.next = temp
temp.prev = node
node = node.next
return head

return helper(head)
```

## Problem solution in Java.

```class Solution {
public Node flatten(Node head) {

Node refHead = head;

while (refHead != null) {

Node next = refHead.next;

Node child = flatten(refHead.child);

Node childRef = child;
while (child != null && child.next != null) {

child = child.next;
}

if (childRef != null) {
refHead.child = null;
refHead.next = childRef;
childRef.prev = refHead;

child.next = next;
if (next != null) {

next.prev = child;
}
}

refHead = next;
}

return head;
}
}
```

## Problem solution in C++.

```class Solution {
public:
Node* flatten(Node* head) {
flattenEnd(head);
return head;
}
Node *flattenEnd(Node *head)
{
if (!head) return head;
Node *fp = head, *next;
while (fp)
{
next = fp->next;
if (fp->child)
{
Node *end = flattenEnd(fp->child);
fp->next = fp->child;
fp->next->prev = fp;
fp->child = NULL;
fp = end;
fp->next = next;
if(next)
next->prev = end;
}
if (!next)
break;
fp = next;

}
return fp;
}
};
```