Flatten a multilevel doubly LinkedList in Python - python-3.x

Question

I am working on LeetCode problem 430. Flatten a Multilevel Doubly Linked List:
You are given a doubly linked list, which contains nodes that have a
next pointer, a previous pointer, and an additional child pointer.
This child pointer may or may not point to a separate doubly linked
list, also containing these special nodes. 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.
Given the head of the first level of the list, flatten the list so
that all the nodes appear in a single-level, doubly linked list. Let
curr be a node with a child list. The nodes in the child list should
appear after curr and before curr.next in the flattened list.
Return the head of the flattened list. The nodes in the list must have
all of their child pointers set to null.
My Approach
This is what I intended to do:
Traverse through the head node and wherever a child node appears, change the link of the current node to the child node.
Then, add all the nodes traversed to a separate LList (in my code it is ll). I have kept dummy at the head of the new LList.
While reaching at every child node, add that node address to a stack. So, when doing a pop() operation, the last child node added will be retrieved first.
After that, pop and iterate through that child node till None and add new nodes to new LList i.e. ll. Lastly, return dummy.next
My Code
class Solution:
def flatten(self, head: 'Optional[Node]') -> 'Optional[Node]':
curr = head
ll = dummy = ListNode(0)
stack = []
while curr:
if curr.child:
stack.append(curr)
ll.next = curr
curr.next = curr.child
else:
ll.next = curr
ll = ll.next
curr = curr.next
while stack:
curr_node = stack.pop()
while curr_node:
ll.next = curr_node
ll = ll.next
curr_node = curr_node.next
return dummy.next
The Problem
I am getting a Time Limit Exceeded warning. Can someone please tell me if I am correct with my approach and where I am going wrong?

Answer 1

The second part of your code is creating a cycle in the ll list. The node that you pop from the stack was already put in the ll list at the time you pushed that node on the stack. But you append it again to the ll list, making a cycle. And so while curr_node: is becoming an infinite loop.
The general idea for the algorithm is fine though, but push the next node on the stack, instead of the current node.
Furthermore, you should:
Clear the child reference once you have processed it
Adapt the prev references, so they are consistent with the changes to some of the next references. Remember: it is a doubly linked list you get and need to return.
I would not:
Lag behind with a separate ll reference. You can just work with curr
Use the dummy node. Although I understand its utility, once you have dealt with the case of the empty list (as a boundary case), there is really no benefit anymore
So here is how I would do it:
class Solution:
def flatten(self, head: 'Optional[Node]') -> 'Optional[Node]':
if not head:
return
stack = []
current = head
while current:
if current.child:
if current.next:
stack.append(current.next)
current.next = current.child
current.next.prev = current
current.child = None
elif not current.next and stack:
current.next = stack.pop()
current.next.prev = current
current = current.next
return head