C中指向链表的动态分配数组

以下是一个C语言中动态分配链表的数组的示例代码：

#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int data;
    struct Node* next;
} Node;

int main() {
    int n; // 链表数组的大小
    printf("Enter the size of the linked list array: ");
    scanf("%d", &n);

    Node** linkedListArray = (Node**)malloc(n * sizeof(Node*)); // 动态分配链表数组

    // 初始化链表数组
    for (int i = 0; i < n; i++) {
        linkedListArray[i] = NULL;
    }

    // 向链表数组中的每个链表插入节点
    for (int i = 0; i < n; i++) {
        int m; // 链表中的节点数
        printf("Enter the number of nodes in linked list %d: ", i+1);
        scanf("%d", &m);

        Node* head = NULL;
        Node* current = NULL;

        // 创建链表
        for (int j = 0; j < m; j++) {
            int data;
            printf("Enter the data for node %d: ", j+1);
            scanf("%d", &data);

            Node* newNode = (Node*)malloc(sizeof(Node));
            newNode->data = data;
            newNode->next = NULL;

            if (head == NULL) {
                head = newNode;
                current = newNode;
            }
            else {
                current->next = newNode;
                current = current->next;
            }
        }

        // 将链表赋给链表数组中的对应位置
        linkedListArray[i] = head;
    }

    // 打印链表数组中的每个链表
    for (int i = 0; i < n; i++) {
        printf("Linked list %d: ", i+1);

        Node* current = linkedListArray[i];
        while (current != NULL) {
            printf("%d -> ", current->data);
            current = current->next;
        }
        printf("NULL\n");
    }

    // 释放链表数组中的每个链表的内存
    for (int i = 0; i < n; i++) {
        Node* current = linkedListArray[i];
        while (current != NULL) {
            Node* temp = current;
            current = current->next;
            free(temp);
        }
    }

    // 释放链表数组的内存
    free(linkedListArray);

    return 0;
}

这个示例中，首先从用户处获取链表数组的大小。然后，通过使用malloc函数动态分配一个指向链表的指针数组。接下来，使用循环初始化链表数组中的每个链表为空。然后，使用另一个循环向链表数组中的每个链表插入节点。在每个链表中，通过使用malloc函数动态分配一个新的节点，并将其插入链表中。最后，使用另一个循环打印链表数组中的每个链表。在释放内存之前，需要使用两个循环来释放链表数组中的每个链表的内存，然后再释放链表数组的内存。