C++ 程序展平多级链表深度明智 - 集 2

我们已经讨论了多级链表的扁平化，其中节点有两个指针 down 和 next。在上一篇文章中，我们将链表逐层展平。当我们总是需要在每个节点的 next 之前处理向下指针时，如何展平链表。

Input:  
1 - 2 - 3 - 4
    |
    7 -  8 - 10 - 12
    |    |    |
    9    16   11
    |    |
    14   17 - 18 - 19 - 20
    |                    |
    15 - 23             21
         |
         24

Output:        
Linked List to be flattened to
1 - 2 - 7 - 9 - 14 - 15 - 23 - 24 - 8
 - 16 - 17 - 18 - 19 - 20 - 21 - 10 - 
11 - 12 - 3 - 4
Note: 9 appears before 8 (When we are 
at a node, we process down pointer before 
right pointer)

资料来源：甲骨文采访

如果我们仔细观察，我们会注意到这个问题类似于树到链表的转换。我们通过以下步骤递归地展平一个链表：

1. 如果节点为 NULL，则返回 NULL。
2. 存储当前节点的下一个节点（在步骤 4 中使用）。
3. 递归地展平列表。在展平时，跟踪最后访问的节点，以便在它之后链接下一个列表。
4. 递归地展平下一个列表（我们从步骤 2 中存储的指针获取下一个列表）并将其附加到最后访问的节点之后。

下面是上述思想的实现。

C++

// C++ program to flatten a multilevel 
// linked list
#include 
using namespace std;
  
// A Linked List Node
struct Node
{
    int data;
    struct Node *next;
    struct Node *down;
};
  
// Flattens a multi-level linked 
// list depth wise
Node* flattenList(Node* node)
{
    // Base case
    if (node == NULL)
        return NULL;
  
    // To keep track of last visited node
    // (NOTE: This is static)
    static Node *last;
    last = node;
  
    // Store next pointer
    Node *next = node->next;
  
    // If down list exists, process it 
    // first. Add down list as next of 
    // current node
    if (node->down)
       node->next = flattenList(node->down);
  
    // If next exists, add it after the next
    // of last added node
    if (next)
       last->next = flattenList(next);
  
    return node;
}
  
// Utility method to print a 
// linked list
void printFlattenNodes(Node* head)
{
    while (head) 
    { 
    printf("%d ", head->data); 
    head = head->next; 
    } 
     
}
  
// Utility function to create a 
// new node
Node* newNode(int new_data)
{
    Node* new_node = new Node;
    new_node->data = new_data;
    new_node->next = new_node->down = NULL;
    return new_node;
}
  
// Driver code
int main()
{
    // Creating above example list
    Node* head = newNode(1);
    head->next = newNode(2);
    head->next->next = newNode(3);
    head->next->next->next = newNode(4);
    head->next->down = newNode(7);
    head->next->down->down = newNode(9);
    head->next->down->down->down =  
    newNode(14);
    head->next->down->down->down->down = 
    newNode(15);
    head->next->down->down->down->down->next = 
    newNode(23);
    head->next->down->down->down->down->next->down = 
    newNode(24);
    head->next->down->next = newNode(8);
    head->next->down->next->down = newNode(16);
    head->next->down->next->down->down = 
    newNode(17);
    head->next->down->next->down->down->next = 
    newNode(18);
    head->next->down->next->down->down->next->next = 
    newNode(19);
    head->next->down->next->down->down->next->next->next = 
    newNode(20);
    head->next->down->next->down->down->next->next->next->down = 
    newNode(21);
    head->next->down->next->next = newNode(10);
    head->next->down->next->next->down = newNode(11);
    head->next->down->next->next->next = newNode(12);
  
    // Flatten list and print modified list
    head = flattenList(head);
    printFlattenNodes(head);
  
    return 0;
}

输出：

1 2 7 9 14 15 23 24 8 16 17 18 19 20 21 10 11 12 3 4

使用堆栈数据结构的替代实现

C++

Node* flattenList2(Node* head)
{
    Node* headcop = head;
    stack save;
    save.push(head);
    Node* prev = NULL;
  
    while (!save.empty()) 
    {
        Node* temp = save.top();
        save.pop();
  
        if (temp->next)
            save.push(temp->next);
        if (temp->down)
            save.push(temp->down);
        if (prev != NULL)
            prev->next = temp;
  
        prev = temp;
    }
    return headcop;
}

请参考关于扁平化多级链表的完整文章 | Set 2 (Depth wise) 了解更多详情！