C语言基础-动态数组

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

// 定义动态数组结构体
typedef struct {
    int* data;          // 数据存储区域
    size_t size;        // 当前元素个数
    size_t capacity;    // 当前容量
} DynamicArray;

// 初始化动态数组
DynamicArray* createArray(size_t initialCapacity) {
    DynamicArray* arr = (DynamicArray*)malloc(sizeof(DynamicArray));
    if (arr == NULL) {
        return NULL;
    }
    
    arr->data = (int*)malloc(initialCapacity * sizeof(int));
    if (arr->data == NULL) {
        free(arr);
        return NULL;
    }
    
    arr->size = 0;
    arr->capacity = initialCapacity;
    return arr;
}

// 检查是否需要扩容
int ensureCapacity(DynamicArray* arr) {
    if (arr->size >= arr->capacity) {
        // 扩容为原来的2倍
        size_t newCapacity = arr->capacity * 2;
        int* newData = (int*)realloc(arr->data, newCapacity * sizeof(int));
        if (newData == NULL) {
            return 0; // 扩容失败
        }
        
        arr->data = newData;
        arr->capacity = newCapacity;
    }
    return 1; // 成功
}

// 在数组末尾添加元素
int append(DynamicArray* arr, int element) {
    if (!ensureCapacity(arr)) {
        return 0; // 添加失败
    }
    
    arr->data[arr->size++] = element;
    return 1; // 添加成功
}

// 在指定位置插入元素
int insert(DynamicArray* arr, size_t index, int element) {
    // 检查索引是否有效
    if (index > arr->size) {
        return 0;
    }
    
    // 确保有足够空间
    if (!ensureCapacity(arr)) {
        return 0;
    }
    
    // 将插入位置后的元素向后移动
    for (size_t i = arr->size; i > index; i--) {
        arr->data[i] = arr->data[i - 1];
    }
    
    arr->data[index] = element;
    arr->size++;
    return 1;
}

// 删除指定位置的元素
int removeAt(DynamicArray* arr, size_t index) {
    // 检查索引是否有效
    if (index >= arr->size) {
        return 0;
    }
    
    // 将删除位置后的元素向前移动
    for (size_t i = index; i < arr->size - 1; i++) {
        arr->data[i] = arr->data[i + 1];
    }
    
    arr->size--;
    return 1;
}

// 获取指定位置的元素
int get(DynamicArray* arr, size_t index, int* element) {
    if (index >= arr->size) {
        return 0;
    }
    
    *element = arr->data[index];
    return 1;
}

// 修改指定位置的元素
int set(DynamicArray* arr, size_t index, int element) {
    if (index >= arr->size) {
        return 0;
    }
    
    arr->data[index] = element;
    return 1;
}

// 获取数组大小
size_t size(DynamicArray* arr) {
    return arr->size;
}

// 获取数组容量
size_t capacity(DynamicArray* arr) {
    return arr->capacity;
}

// 清空数组
void clear(DynamicArray* arr) {
    arr->size = 0;
}

// 释放动态数组内存
void freeArray(DynamicArray* arr) {
    if (arr) {
        free(arr->data);
        free(arr);
    }
}

// 缩减数组容量以适应当前大小
int shrinkToFit(DynamicArray* arr) {
    if (arr->size < arr->capacity) {
        int* newData = (int*)realloc(arr->data, arr->size * sizeof(int));
        if (newData == NULL && arr->size > 0) {
            return 0; // 收缩失败
        }
        
        arr->data = newData;
        arr->capacity = arr->size;
    }
    return 1;
}

// 查找元素，返回第一个匹配的索引
int find(DynamicArray* arr, int element) {
    for (size_t i = 0; i < arr->size; i++) {
        if (arr->data[i] == element) {
            return i;
        }
    }
    return -1; // 未找到
}

// 示例用法
int main() {
    // 创建动态数组
    DynamicArray* arr = createArray(5);
    if (arr == NULL) {
        printf("创建动态数组失败！\n");
        return 1;
    }
    
    // 添加元素
    append(arr, 10);
    append(arr, 20);
    append(arr, 30);
    
    printf("数组大小: %zu\n", size(arr));
    printf("数组容量: %zu\n", capacity(arr));
    
    // 插入元素
    insert(arr, 1, 15);
    
    // 遍历数组
    printf("数组元素: ");
    for (size_t i = 0; i < size(arr); i++) {
        int element;
        get(arr, i, &element);
        printf("%d ", element);
    }
    printf("\n");
    
    // 删除元素
    removeAt(arr, 2);
    
    // 修改元素
    set(arr, 0, 5);
    
    // 查找元素
    int index = find(arr, 15);
    if (index != -1) {
        printf("找到元素15，位置: %d\n", index);
    }
    
    // 再次遍历数组
    printf("修改后的数组元素: ");
    for (size_t i = 0; i < size(arr); i++) {
        int element;
        get(arr, i, &element);
        printf("%d ", element);
    }
    printf("\n");
    
    // 缩减容量
    shrinkToFit(arr);
    printf("缩减后的容量: %zu\n", capacity(arr));
    
    // 清空数组
    clear(arr);
    printf("清空后的大小: %zu\n", size(arr));
    
    // 释放内存
    freeArray(arr);
    
    return 0;
}