扁平化多级双向链表

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

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

链接：https://leetcode-cn.com/problems/flatten-a-multilevel-doubly-linked-list

示例 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]
解释：
输入的多级列表如下图所示：

扁平化后的链表如下图：

一、dfs

借用官方的图：

思路分析：深度优先搜索，当遇到child节点不为空时，先搜索child节点，再继续搜索next节点。

1. 借用一个vector空间，里面存放搜索到的节点
2. 遍历链表
3. child不为空，先搜索child分支上的节点
4. 再继续搜索next节点
5. 遍历完成返回，将vector中节点链接起来

child节点搜索完之后，一定要置为空。

代码：

class Solution {
public:
    vector<Node*> vn;
    void dfs(Node* head)
    {
        if(head == nullptr)
            return;
        vn.push_back(head);//将节点放入
        if(head->child != nullptr)//child不为空，先搜索child分支节点
        {    
            dfs(head->child);
            head->child = nullptr;//置为空
        }
        dfs(head->next);//搜索下一个节点
    }
    Node* flatten(Node* head) {
        if(head == nullptr)
            return nullptr;
        dfs(head);//dfs搜索
        int sz = vn.size();
        for(int i = 1; i < sz; ++i)//链接起来
        {
            vn[i - 1]->next = vn[i];
            vn[i]->prev = vn[i - 1];
        }
        return vn[0];//返回
    }
};

二、迭代

思路分析：借用一个栈，遍历链表，如果某节点有child，则将该节点入栈，然后遍历child节点分支，此时child分支走到末尾时，链接节点。

1. 借用辅助栈，遍历链表
2. 如child不为空，将该节点入栈，然后遍历child节点分支
3. child分支为空，链接链表
4. 具体链接细节都在代码里了

代码：

class Solution {
public:
    Node* flatten(Node* head) {
        if(head == nullptr)
            return nullptr;
        stack<Node*> st;
        Node* p = head;
        while(p != nullptr || !st.empty())
        {
            if(p->child != nullptr)
            {
                st.push(p);//push进去
                p->child->prev = p;//先改变child->prev指向
                p = p->child;//改变当前节点，遍历child节点分支
            }

            if(p->next == nullptr && !st.empty())
            {
                Node* tmp = st.top();//child分支为空，栈不为空，则链接链表
                if(tmp-> next != nullptr)//父节点next不为空，则链接child节点的尾节点
                {
                    p->next = tmp->next;
                    tmp->next->prev = p;
                }
                tmp->next = tmp->child;//改变父节点next指向
                p = tmp;//重新改变p的位置,将p指向父节点的位置
                tmp->child = nullptr;//把child节点置为空
                st.pop();
            }
            p = p->next;
        }
        return head;
    }
};