顺序表

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

// ArrayList结构体
typedef struct {
    void **data;        // 存储数据的指针数组
    int size;          // 当前元素数量
    int capacity;      // 当前容量
    int element_size;  // 每个元素的大小（字节）
} ArrayList;

// 创建ArrayList
ArrayList* arraylist_create(int initial_capacity, int element_size) {
    ArrayList *list = (ArrayList*)malloc(sizeof(ArrayList));
    if (!list) return NULL;
    
    list->data = (void**)malloc(sizeof(void*) * initial_capacity);
    if (!list->data) {
        free(list);
        return NULL;
    }
    
    list->size = 0;
    list->capacity = initial_capacity;
    list->element_size = element_size;
    return list;
}

// 销毁ArrayList
void arraylist_destroy(ArrayList *list) {
    if (!list) return;
    
    // 释放所有元素的内存
    for (int i = 0; i < list->size; i++) {
        free(list->data[i]);
    }
    
    free(list->data);
    free(list);
}

// 扩容
static int arraylist_resize(ArrayList *list, int new_capacity) {
    void **new_data = (void**)realloc(list->data, sizeof(void*) * new_capacity);
    if (!new_data) return 0;
    
    list->data = new_data;
    list->capacity = new_capacity;
    return 1;
}

// 确保有足够容量
static int arraylist_ensure_capacity(ArrayList *list, int min_capacity) {
    if (min_capacity <= list->capacity) return 1;
    
    // 按1.5倍扩容
    int new_capacity = list->capacity * 3 / 2;
    if (new_capacity < min_capacity) {
        new_capacity = min_capacity;
    }
    
    return arraylist_resize(list, new_capacity);
}

// 在末尾添加元素
int arraylist_add(ArrayList *list, const void *element) {
    if (!arraylist_ensure_capacity(list, list->size + 1)) {
        return 0;
    }
    
    void *new_element = malloc(list->element_size);
    if (!new_element) return 0;
    
    memcpy(new_element, element, list->element_size);
    list->data[list->size] = new_element;
    list->size++;
    return 1;
}

// 在指定位置插入元素
int arraylist_insert(ArrayList *list, int index, const void *element) {
    if (index < 0 || index > list->size) return 0;
    
    if (!arraylist_ensure_capacity(list, list->size + 1)) {
        return 0;
    }
    
    // 移动元素
    for (int i = list->size; i > index; i--) {
        list->data[i] = list->data[i - 1];
    }
    
    void *new_element = malloc(list->element_size);
    if (!new_element) return 0;
    
    memcpy(new_element, element, list->element_size);
    list->data[index] = new_element;
    list->size++;
    return 1;
}

// 删除指定位置的元素
int arraylist_remove(ArrayList *list, int index) {
    if (index < 0 || index >= list->size) return 0;
    
    free(list->data[index]);
    
    // 移动元素
    for (int i = index; i < list->size - 1; i++) {
        list->data[i] = list->data[i + 1];
    }
    
    list->size--;
    return 1;
}

// 获取指定位置的元素
void* arraylist_get(const ArrayList *list, int index) {
    if (index < 0 || index >= list->size) return NULL;
    return list->data[index];
}

// 设置指定位置的元素
int arraylist_set(ArrayList *list, int index, const void *element) {
    if (index < 0 || index >= list->size) return 0;
    
    memcpy(list->data[index], element, list->element_size);
    return 1;
}

// 查找元素，返回索引
int arraylist_index_of(const ArrayList *list, const void *element, 
                      int (*compare)(const void*, const void*)) {
    for (int i = 0; i < list->size; i++) {
        if (compare(list->data[i], element) == 0) {
            return i;
        }
    }
    return -1;
}

// 清空ArrayList
void arraylist_clear(ArrayList *list) {
    for (int i = 0; i < list->size; i++) {
        free(list->data[i]);
    }
    list->size = 0;
}

// 获取元素数量
int arraylist_size(const ArrayList *list) {
    return list->size;
}

// 判断是否为空
int arraylist_is_empty(const ArrayList *list) {
    return list->size == 0;
}

// 遍历ArrayList
void arraylist_foreach(const ArrayList *list, void (*action)(void*)) {
    for (int i = 0; i < list->size; i++) {
        action(list->data[i]);
    }
}

// 打印ArrayList信息
void arraylist_print_info(const ArrayList *list) {
    printf("ArrayList: size=%d, capacity=%d, element_size=%d\n", 
           list->size, list->capacity, list->element_size);
}

// 示例：比较函数（用于int类型）
int compare_int(const void *a, const void *b) {
    int int_a = *(int*)a;
    int int_b = *(int*)b;
    return (int_a > int_b) - (int_a < int_b);
}

// 示例：打印函数（用于int类型）
void print_int(void *element) {
    printf("%d ", *(int*)element);
}

// 测试示例
int main() {
    // 创建存储int的ArrayList
    ArrayList *list = arraylist_create(5, sizeof(int));
    
    printf("=== ArrayList测试 ===\n");
    
    // 添加元素
    for (int i = 0; i < 10; i++) {
        int value = i * 10;
        arraylist_add(list, &value);
    }
    
    printf("添加10个元素后:\n");
    arraylist_print_info(list);
    printf("元素: ");
    arraylist_foreach(list, print_int);
    printf("\n\n");
    
    // 插入元素
    int insert_value = 999;
    arraylist_insert(list, 3, &insert_value);
    printf("在索引3插入999后:\n");
    printf("元素: ");
    arraylist_foreach(list, print_int);
    printf("\n\n");
    
    // 删除元素
    arraylist_remove(list, 5);
    printf("删除索引5的元素后:\n");
    printf("元素: ");
    arraylist_foreach(list, print_int);
    printf("\n\n");
    
    // 查找元素
    int search_value = 999;
    int index = arraylist_index_of(list, &search_value, compare_int);
    printf("查找999的位置: %d\n\n", index);
    
    // 修改元素
    int modify_value = 888;
    arraylist_set(list, 2, &modify_value);
    printf("修改索引2为888后:\n");
    printf("元素: ");
    arraylist_foreach(list, print_int);
    printf("\n\n");
    
    // 获取元素
    int *element = (int*)arraylist_get(list, 0);
    if (element) {
        printf("索引0的元素: %d\n", *element);
    }
    
    // 清空
    arraylist_clear(list);
    printf("\n清空后大小: %d, 是否为空: %d\n", 
           arraylist_size(list), arraylist_is_empty(list));
    
    arraylist_destroy(list);
    return 0;
}