从 C 语言动态数组到顺序表-1:实现动态数组的基本操作-优快云博客

🧱 第一步：静态数组的局限

我们先看一个常见的静态数组操作：

int num[11] = {0,1,2,3,4,5,6,7,8,9};

问题来了：

大小固定，无法扩容
插入时要手动移动元素
删除后要手动补空

虽然可以用函数封装 insert、delete、search，但数组大小依然是硬伤。

🚀 第二步：用 `malloc` 和 `realloc` 实现动态数组

C 语言虽然没有“动态数组”，但我们可以通过 动态内存管理 模拟它！

✅ 核心思路：

使用 malloc 分配初始空间
使用 realloc 实现扩容
用指针管理数组
用变量记录当前长度

📦 动态数组的完整实现

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

// 打印数组
void printarray(int* arr, int length) {
    for (int i = 0; i < length; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

// 初始化数组
void initnum(int* arr, int length) {
    for (int i = 0; i < length; i++) {
        arr[i] = 0;
    }
}

// 插入元素
int* insertnum(int* arr, int* length, int location, int value) {
    if (location < 0 || location > *length) {
        printf("Invalid location!\n");
        return arr;
    }

    // 扩容
    void* temp = realloc(arr, (*length + 1) * sizeof(int));
    if (temp == NULL) {
        perror("realloc");
        return arr;
    }
    arr = (int*)temp;

    // 从后往前移动元素
    for (int i = *length - 1; i >= location; i--) {
        arr[i + 1] = arr[i];
    }

    // 插入新值
    arr[location] = value;
    (*length)++;  // 更新长度

    return arr;
}

// 删除元素
int deletenum(int* arr, int length, int location) {
    if (location < 0 || location >= length) {
        printf("Invalid location!\n");
        return 1;
    }
    for (int i = location; i < length - 1; i++) {
        arr[i] = arr[i + 1];
    }
    arr[length - 1] = 0;
    return 0;
}

// 查找元素（返回第几个，从1开始）
int searchnum(int* arr, int length, int value) {
    for (int i = 0; i < length; i++) {
        if (arr[i] == value) {
            return i + 1;  // 返回第几个元素
        }
    }
    return 0;  // 未找到
}

🧪 主函数测试

int main() {
    int length = 10;
    int* num = (int*)malloc(length * sizeof(int));
    if (num == NULL) {
        printf("Memory allocation failed!\n");
        return 1;
    }

    initnum(num, length);
    printarray(num, length);  // 0 0 0 0 0 0 0 0 0 0

    for (int i = 0; i < length; i++) {
        num[i] = i;
    }
    printarray(num, length);  // 0 1 2 3 4 5 6 7 8 9

    insertnum(num, &length, 5, 66);
    printarray(num, length);  // 插入 66

    deletenum(num, length, 6);
    printarray(num, length);  // 删除第6个

    int found = searchnum(num, length, 99); // 第二个运行结果图中，把99改成了66
    if (found) {
        printf("找到了，在第%d个元素位置\n", found);
    } else {
        printf("没有找到\n");
    }

    free(num);
    return 0;
}

✅ 程序输出结果：

0 0 0 0 0 0 0 0 0 0 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 66 5 6 7 8 9 
0 1 2 3 4 66 6 7 8 9 0 
没有找到

0 0 0 0 0 0 0 0 0 0 
0 1 2 3 4 5 6 7 8 9 
0 1 2 3 4 66 5 6 7 8 9 
0 1 2 3 4 66 6 7 8 9 0 
找到了，在第6个元素位置

🎯 第三步：我们遇到了什么问题？

虽然上面的代码能工作，但存在几个“别扭”的地方：

问题	描述
❌ 参数太多	每次调用都要传 `arr` 和 `length`
❌ `length` 是 `int*`	插入时要传 `&length`，容易出错
❌ 无法封装 `capacity`	没有记录容量，每次插入都 `realloc`，效率低
❌ 不够“对象化”	缺少整体管理