leetcode中等430扁平化多级双向链表

Posted 2021-10-14 qq_40707462

多级双向链表中，除了指向下一个节点和前一个节点指针之外，它还有一个子链表指针，可能指向单独的双向链表。这些子列表也可能会有一个或多个自己的子项，依此类推，生成多级数据结构，如下面的示例所示。

给你位于列表第一级的头节点，请你扁平化列表，使所有结点出现在单级双链表中。

相当于前序遍历，中左右，中-child-next，得到顺序后再串成双向链表

思路一：前序遍历

"""
# Definition for a Node.
class Node:
    def __init__(self, val, prev, next, child):
        self.val = val
        self.prev = prev
        self.next = next
        self.child = child
"""

class Solution:
    def flatten(self, head: 'Node') -> 'Node':
        if not head:
            return
        res=[]
        
        def dfs(root):
            if not root:
                return
            res.append(root)
            dfs(root.child)
            dfs(root.next)

        dfs(head)
        res[0].pre=None
        res[0].child=None
        for i in range(1,len(res)):
            res[i-1].next=res[i]
            res[i].prev=res[i-1]
            res[i].child=None
        res[-1].child=None
        return res[0]

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

class Solution {
    List<Node> arr=new ArrayList<>();
    public Node flatten(Node head) {
        if(head==null) return null;
        dfs(head);
        Node t=arr.get(0);
        Node res=t;
        for(int i=1;i<arr.size();i++){
            res.next=arr.get(i);
            res.child=null;
            res.next.prev=res;
            res.next.child=null;
            res=res.next;
        }
        return t;
    }
    public void dfs(Node head){
        if(head==null) return;
        arr.add(head);
        dfs(head.child);
        dfs(head.next);
    }
}

思路二：借助栈，对于当前节点cur，暂存next入栈，先把child放在next的位置，然后cur=cur.next或栈中弹出

class Solution {
    public Node flatten(Node head) {
        if(head==null) return null;
        LinkedList<Node> stack=new LinkedList<>();//List<Node>就没有push，pop函数了
        Node cur=head;

        while(true){
            //先child再next
            if(cur.child!=null){
                //next入栈
                if(cur.next!=null){
                     stack.push(cur.next);
                }
                //cur-child-next
                cur.next=cur.child;
                cur.next.prev=cur;
                cur.child=null;   //记得child置空
            }
            //接着遍历cur的next，没有的话从stack里找
            if(cur.next!=null){
                cur=cur.next;
            }else if(!stack.isEmpty()){
                Node next=stack.pop();
                cur.next=next;
                next.prev=cur;
                cur=next;
            }else{
                return head;
            }
        }
    }
}