用c语言写一段动态数组的代码

以下是一个简单的动态数组实现的 C 代码示例：

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

int main() {
    int size, i, *arr;

    printf("Enter size of array: ");
    scanf("%d", &size);

    // 分配动态内存
    arr = (int*) malloc(size * sizeof(int));

    // 存储数据
    for (i = 0; i < size; i++) {
        printf("Enter element %d: ", i+1);
        scanf("%d", &arr[i]);
    }

    // 输出数据
    printf("Elements in array are: ");
    for (i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }

    // 释放动态内存
    free(arr);
    arr = NULL;

    return 0;
}

这段代码中，我们使用了 `malloc` 函数来分配动态内存，使用了指针 `arr` 来保存数组的地址。我们也使用了 `free` 函数来释放动态内存，避免内存泄漏。

相关问题

使用C语言开辟一段动态数组malloc

在C语言中，可以使用malloc函数来动态地分配内存空间以创建一个动态数组。malloc函数的原型如下：

void* malloc(size_t size);

其中，size_t是一个无符号整数类型，表示要分配的内存空间的大小（以字节为单位）。malloc函数返回一个指向分配内存空间的指针，如果分配失败，则返回NULL。

下面是使用malloc函数创建动态数组的步骤：

1. 确定要创建的动态数组的元素类型和元素个数。
2. 计算需要分配的内存空间的大小，即元素类型的大小乘以元素个数。
3. 调用malloc函数分配内存空间，并将返回的指针赋给一个指针变量。
4. 检查malloc函数是否成功分配了内存空间（即返回的指针是否为NULL）。
5. 使用分配的内存空间来存储数据。

下面是一个示例代码，演示了如何使用malloc函数创建一个动态数组：

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

int main() {
    int n;  // 动态数组的元素个数
    int* arr;  // 指向动态数组的指针

    printf("请输入动态数组的元素个数：");
    scanf("%d", &n);

    // 计算需要分配的内存空间的大小
    size_t size = n * sizeof(int);

    // 调用malloc函数分配内存空间
    arr = (int*)malloc(size);

    // 检查malloc函数是否成功分配了内存空间
    if (arr == NULL) {
        printf("内存分配失败！\n");
        return 1;
    }

    // 使用动态数组存储数据
    for (int i = 0; i < n; i++) {
        printf("请输入第%d个元素的值：", i + 1);
        scanf("%d", &arr[i]);
    }

    // 打印动态数组的元素
    printf("动态数组的元素为：");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    // 释放动态数组所占用的内存空间
    free(arr);

    return 0;
}

用C语言写一段用数组的链表代码

由于“数组的链表”一词理解起来有些困难，这里我提供两个数组相关的链表代码。

1. 数组实现的链表

这种链表的实现方式是使用一个指针数组和一个可用位置的指针来表示链表。节点的数据存放在数组中，通过数组下标来访问。链表的头节点指针指向第一个可用位置的指针，链表的尾节点指针指向最后一个非可用位置的指针。

#define MAX_NODE 100

int data[MAX_NODE];
int next[MAX_NODE];
int head;
int tail;
int free_pos;

void init() {
    for (int i = 0; i < MAX_NODE; i++) {
        next[i] = i + 1;
    }
    next[MAX_NODE - 1] = -1;
    free_pos = 0;
    head = -1;
    tail = -1;
}

int allocate_node() {
    if (free_pos == -1) {
        return -1;  // 标记无可用节点
    }
    int pos = free_pos;
    free_pos = next[pos];
    return pos;
}

void free_node(int pos) {
    next[pos] = free_pos;
    free_pos = pos;
}

void insert(int val) {
    int pos = allocate_node();
    if (pos == -1) {
        return;  // 链表已满
    }
    data[pos] = val;
    next[pos] = -1;
    if (head == -1) {
        head = pos;
    } else {
        next[tail] = pos;
    }
    tail = pos;
}

void remove(int val) {
    int curr = head;
    int prev = -1;
    while (curr != -1 && data[curr] != val) {
        prev = curr;
        curr = next[curr];
    }
    if (curr == -1) {
        return;  // 没有找到值为val的节点
    }
    if (prev == -1) {
        head = next[curr];
    } else {
        next[prev] = next[curr];
    }
    free_node(curr);
}

void show() {
    int curr = head;
    while (curr != -1) {
        printf("%d ", data[curr]);
        curr = next[curr];
    }
    printf("\n");
}

2. 动态数组实现的链表

这种链表的实现方式是使用动态数组，数组中的元素是节点指针，每个节点指针指向一个节点。链表的头节点指针指向第一个节点，链表的尾节点指针指向最后一个节点。当链表需要扩容时，动态数组会重新分配更大的内存，并将原有元素复制到新的内存中。

#include <stdlib.h>

typedef struct node_t {
    int val;
    struct node_t* next;
} node_t;

int size;
int capacity;
node_t** nodes;

void init() {
    size = 0;
    capacity = 1;
    nodes = (node_t**)malloc(capacity * sizeof(node_t*));
    nodes[0] = NULL;
}

void insert(int val) {
    node_t* node = (node_t*)malloc(sizeof(node_t));
    node->val = val;
    node->next = NULL;
    nodes[size] = node;
    size++;
    if (size == capacity) {
        capacity *= 2;
        nodes = (node_t**)realloc(nodes, capacity * sizeof(node_t*));
    }
    if (size == 1) {
        nodes[0] = node;
    } else {
        nodes[size - 2]->next = node;
    }
}

void remove(int val) {
    node_t* curr = nodes[0];
    node_t* prev = NULL;
    while (curr != NULL && curr->val != val) {
        prev = curr;
        curr = curr->next;
    }
    if (curr == NULL) {
        return;  // 没有找到值为val的节点
    }
    if (prev == NULL) {
        nodes[0] = curr->next;
    } else {
        prev->next = curr->next;
    }
    free(curr);
    size--;
    if (size <= capacity / 2) {
        capacity /= 2;
        nodes = (node_t**)realloc(nodes, capacity * sizeof(node_t*));
    }
}

void show() {
    node_t* curr = nodes[0];
    while (curr != NULL) {
        printf("%d ", curr->val);
        curr = curr->next;
    }
    printf("\n");
}