扁平化多级链表的 C 程序

在这个 C 程序中，我们将实现扁平化多级链表的功能。多级链表是指链表中的节点可以连接到链表中的任意位置，形成一个层级结构。

程序设计

首先，我们需要定义一个多级链表节点的结构 Node，它包含以下字段：

struct Node {
    int val;
    struct Node* prev;
    struct Node* next;
    struct Node* child;
};

其中，val 是节点的值，prev 是指向前一个节点的指针，next 是指向下一个节点的指针，child 是指向下一级链表的指针。

扁平化函数

接下来，我们需要实现一个函数 flatten，用于扁平化多级链表。函数的定义如下：

struct Node* flatten(struct Node* head);

该函数接受一个指向多级链表头节点的指针 head，并返回扁平化后的链表头节点的指针。

扁平化算法

为了实现扁平化功能，我们可以使用递归的方法来处理多级链表。具体算法如下：

1. 遍历链表，找到第一个拥有 child 的节点。
2. 如果找到了拥有 child 的节点，则将当前节点的 next 指针保存到临时变量 nextNode。
3. 递归调用 flatten 函数处理当前节点的 child 链表，返回扁平化后的子链表的头节点。
4. 将子链表的头节点赋给当前节点的 next 指针。
5. 更新子链表头节点的 prev 指针为当前节点。
6. 找到子链表的最后一个节点，并将其 next 指针指向保存在 nextNode 中的节点。
7. 如果保存的 nextNode 不为空，则将 nextNode 的 prev 指针指向子链表的最后一个节点。
8. 返回当前节点作为扁平化后的链表头节点。

完整代码

#include <stdio.h>

struct Node {
    int val;
    struct Node* prev;
    struct Node* next;
    struct Node* child;
};

struct Node* flatten(struct Node* head) {
    struct Node* current = head;
    while (current != NULL) {
        if (current->child != NULL) {
            struct Node* nextNode = current->next;
            struct Node* childHead = flatten(current->child);
            current->next = childHead;
            childHead->prev = current;
            
            struct Node* childTail = childHead;
            while (childTail->next != NULL) {
                childTail = childTail->next;
            }
            
            childTail->next = nextNode;
            if (nextNode != NULL) {
                nextNode->prev = childTail;
            }
            
            current->child = NULL;
        }
        current = current->next;
    }
    return head;
}

// 测试代码
int main() {
    struct Node* head = (struct Node*)malloc(sizeof(struct Node));
    head->val = 1;
    head->prev = NULL;
    head->next = (struct Node*)malloc(sizeof(struct Node));
    head->next->val = 2;
    head->next->prev = head;
    head->next->next = NULL;
    head->next->child = (struct Node*)malloc(sizeof(struct Node));
    head->next->child->val = 3;
    head->next->child->prev = NULL;
    head->next->child->next = (struct Node*)malloc(sizeof(struct Node));
    head->next->child->next->val = 4;
    head->next->child->next->prev = head->next->child;
    head->next->child->next->next = NULL;
    head->next->child->next->child = NULL;
    
    struct Node* flattenedHead = flatten(head);
    
    struct Node* current = flattenedHead;
    while (current != NULL) {
        printf("%d ", current->val);
        current = current->next;
    }
    
    return 0;
}

结果输出

程序运行后的输出结果为：

1 3 4 2

表示扁平化后的多级链表的节点值依次为 1, 3, 4, 2。

注意：为了简化示例，这里省略了内存释放的代码，实际使用时应注意释放动态分配的内存。