单链表的动态内存分配

单链表的动态内存分配是指在程序运行时，根据需要动态地分配内存空间来存储链表节点。这种方式可以避免静态内存分配带来的空间浪费和节点数量限制。

在C语言中，可以使用malloc函数来进行动态内存分配。具体实现步骤如下：

1. 定义链表节点结构体，包含数据域和指向下一个节点的指针域。
2. 使用malloc函数分配一个节点的内存空间，并将其转换为链表节点类型的指针。
3. 将数据存储到节点的数据域中。
4. 将节点的指针域指向下一个节点或NULL。
5. 重复步骤2-4，直到所有节点都被创建并连接成链表。

相关问题

用单链表实现内存分配与回收

单链表可以用来实现内存分配与回收。可以定义一个内存块的结构体，包含该块内存的大小和指向下一个内存块的指针。初始时，可以定义一个头指针指向整个链表的头部。当需要分配内存时，可以遍历链表，查找第一个大小足够的内存块，并将其分配出去。如果链表中没有合适的内存块，则可以申请新的内存块并将其加入到链表中。当需要释放内存时，可以将该内存块加入到链表的头部，这样可以方便地重复使用该内存块。具体实现可以参考下面的代码：

#include <iostream>
using namespace std;

// 定义内存块结构体
struct Block {
    int size;
    Block* next;
};

Block* head = NULL;  // 头指针

// 分配内存
void* allocate(int size) {
    // 遍历链表
    Block* p = head;
    Block* prev = NULL;
    while (p) {
        if (p->size >= size) {
            // 找到合适的内存块，分配出去
            void* ptr = p + 1;
            if (p->size == size) {
                // 如果刚好相等，直接删除该内存块
                if (prev) {
                    prev->next = p->next;
                } else {
                    head = p->next;
                }
                delete p;
            } else {
                // 如果大于要求大小，分割出一块给用户
                Block* q = new Block;
                q->size = size;
                q->next = NULL;
                memcpy(q + 1, ptr, size);
                if (prev) {
                    prev->next = q;
                } else {
                    head = q;
                }
                // 剩下的一块仍然加入链表中
                p->size -= size;
                memcpy(ptr, (char*)ptr + size, p->size);
            }
            return ptr;
        }
        prev = p;
        p = p->next;
    }
    // 如果链表中没有合适的内存块，申请新的内存块
    Block* q = new Block;
    q->size = size;
    q->next = head;
    head = q;
    return q + 1;
}

// 释放内存
void deallocate(void* ptr) {
    Block* p = (Block*)ptr - 1;
    p->next = head;
    head = p;
}

int main() {
    // 分配内存
    int* p = (int*)allocate(sizeof(int));
    *p = 123;
    cout << *p << endl;
    // 释放内存
    deallocate(p);
    return 0;
}

帮我写一个C语言版本的单链表，要求不适用动态内存分配

好的，以下是一个C语言版本的单链表，不使用动态内存分配：

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

#define MAX_SIZE 100

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

Node nodes[MAX_SIZE];
int nodeCount = 0;

Node* createNode(int data) {
    Node* node = &nodes[nodeCount++];
    node->data = data;
    node->next = NULL;
    return node;
}

void insertNode(Node** head, int data) {
    Node* node = createNode(data);
    if (*head == NULL) {
        *head = node;
    } else {
        Node* current = *head;
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = node;
    }
}

void deleteNode(Node** head, int data) {
    if (*head == NULL) {
        return;
    }
    if ((*head)->data == data) {
        Node* temp = *head;
        *head = (*head)->next;
        temp->next = NULL;
        return;
    }
    Node* current = *head;
    while (current->next != NULL && current->next->data != data) {
        current = current->next;
    }
    if (current->next != NULL) {
        Node* temp = current->next;
        current->next = current->next->next;
        temp->next = NULL;
    }
}

void printList(Node* head) {
    Node* current = head;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

int main() {
    Node* head = NULL;
    insertNode(&head, 1);
    insertNode(&head, 2);
    insertNode(&head, 3);
    printList(head);
    deleteNode(&head, 2);
    printList(head);
    return 0;
}

这个单链表使用一个静态数组来存储节点，最多可以存储100个节点。在创建节点时，我们返回数组中的一个空闲节点，而不是使用动态内存分配。这个单链表包含了插入节点、删除节点和打印链表的基本操作。