LeetCode 430：扁平化多级双向链表

LeetCode 430：扁平化多级双向链表

题目描述

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

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

【示例 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]

【解释】

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

扁平化后的链表如下图：

【示例 2】

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

【解释

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

1—2---NULL
|
3—NULL

【示例 3】

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

如何表示测试用例中的多级链表？

以 示例 1 为例：

1—2---3—4---5—6–NULL
|
7—8---9—10–NULL
|
11–12–NULL
序列化其中的每一级之后：

[1,2,3,4,5,6,null]
[7,8,9,10,null]
[11,12,null]
为了将每一级都序列化到一起，我们需要每一级中添加值为 null 的元素，以表示没有节点连接到上一级的上级节点。

[1,2,3,4,5,6,null]
[null,null,7,8,9,10,null]
[null,11,12,null]
合并所有序列化结果，并去除末尾的 null 。

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

【提示】

节点数目不超过 1000
1 <= Node.val <= 10^5

解题

    题目要求的是将多级链表转为双链表。
【思路】
    明白题目要求之后，再观察所述的多级链表结构，不难发现我们要做的实质性工作是：“对每一对父子链表，将父节点的下一位指向子节点，并将子节点所在的链表的最后一个节点的下一位指向父节点原下一个节点，并更新前后关系”。以此，将该对父子链表扁平化成一个双链表，当然，多级链表中可能存在多个具有父子链表关系的多级结构，因此要处理每一对父子链表。
    然后考虑实现过程：

1. 从前向后遍历当前链表
2. 如果遇到有子节点的节点，该节点的下一位指向其子节点，子节点的前一位指向父节点。
3. 当前链表来到子节点所在链表，依然从前向后遍历，如果遇到有子节点的节点，返回到2，如果遍历直至最后一个节点，则当前节点的下一位指向父节点原下一个节点，父节点原下一个节点（如果不为空的话）的上一位指向当前节点。并将当前链表拉回父节点所在链表。以此类推，直至结束。
   我觉得，整个过程可以这么说：“在左右方向上是从前到后的，在上下方向上是从底到上（深度优先）的”。

递归

    整个过程中有可能要返回到在父链表的时刻，因此我第一个想到的方法就是利用递归。以下是代码：

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

class Solution {
public:
    Node *end_node = nullptr;  //用于记录子节点所在链表的最后一个节点
    Node* flatten(Node* head) {
        if (head==nullptr)
            return head;
        Node *cur_node = head;
        Node *temp_node = nullptr;
        Node *sub_head = nullptr;
        while (cur_node){
        	// 存在子节点，修改前后关系，进入子节点所在链表过程
            if (cur_node->child){
                temp_node = cur_node->next;
                sub_head = flatten(cur_node->child);
                
                cur_node->next = sub_head;
                sub_head->prev = cur_node;
                cur_node->child = nullptr;
                
                end_node->next = temp_node;
                if (temp_node)  //防止父节点下一位为空
                    temp_node->prev = end_node;
                cur_node = temp_node;
            }
            //不存在子节点，向后遍历
            else{
                end_node = cur_node;
                cur_node = cur_node->next;
            }
        }
        return head;
    }
};

迭代

题目明确给出节点总数小于1000，所以我们应该可以使用递归去完成任务，但是如果实际总节点过多，递归方法就不适用了。通常情况下，递归能完成的工作，我们可以使用迭代的方式去完成，前面说过，整个过程中可能需要返回到之前某个时刻，而且返回过程是逆向的，我想到的是借助先入后出stack结构。以下是迭代方法的代码：

/*
// 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;
        
        stack<Node *> nodes;
        Node *cur_node = head;
        while (1){
            if (cur_node->child){
                nodes.push(cur_node->next);
                cur_node->next = cur_node->child;
                cur_node->child = nullptr;
                cur_node->next->prev = cur_node;
                cur_node = cur_node->next;
            }
            else if (cur_node->next)
                cur_node = cur_node->next;
            else if (nodes.empty())
                break;
            else{
                cur_node->next = nodes.top();
                if (nodes.top() == nullptr)
                    break;
                nodes.top()->prev = cur_node;
                nodes.pop();
                cur_node = cur_node->next;
            }
                
        }
        return head;
    }
};