C 语言实现单向链表(List）

1. c

#include"c_list.h"

List* list_create(size_t data_size) 
{
    List *list = (List*)malloc(sizeof(List));
    if (!list) return NULL;
    list->head = NULL;
    list->tail = NULL;
    list->data_size = data_size;
    list->length = 0;
    return list;
}
// 在末尾添加元素
void list_append(List *list, void *data) 
{
    if (!list || !data) return;
    
    ListNode *node = (ListNode*)malloc(sizeof(ListNode));
    if (!node) return;
    
    node->data = malloc(list->data_size);
    if (!node->data) {
        free(node);
        return;
    }
    
    // 复制数据
    memcpy(node->data, data, list->data_size);
    node->next = NULL;
    
    if (list->length == 0) {
        list->head = node;
        list->tail = node;
    } else {
        list->tail->next = node;
        list->tail = node;
    }
    
    list->length++;
}

// 在指定位置插入元素
int list_insert(List *list, size_t index, void *data) 
{
    if (!list || !data || index > list->length) 
        return -1;  // 无效位置
    
    if (index == list->length) {
        list_append(list, data);
        return 0;
    }
    
    ListNode *node = (ListNode*)malloc(sizeof(ListNode));
    if (!node) return -1;
    
    node->data = malloc(list->data_size);
    if (!node->data) {
        free(node);
        return -1;
    }
    memcpy(node->data, data, list->data_size);
    
    // 在头部插入
    if (index == 0) {
        node->next = list->head;
        list->head = node;
    } else {
        // 找到插入位置的前一个节点
        ListNode *prev = list->head;
        for (size_t i = 0; i < index - 1; i++) {
            prev = prev->next;
        }
        node->next = prev->next;
        prev->next = node;
    }
    
    list->length++;
    return 0;
}
// 删除指定位置元素
int list_remove(List *list, size_t index) 
{
    if (!list || index >= list->length) 
        return -1;  // 无效位置
    
    ListNode *to_delete;
    
    // 删除头节点
    if (index == 0) {
        to_delete = list->head;
        list->head = list->head->next;
        if (list->length == 1) {
            list->tail = NULL;
        }
    } else {
        // 找到删除位置的前一个节点
        ListNode *prev = list->head;
        for (size_t i = 0; i < index - 1; i++) {
            prev = prev->next;
        }
        to_delete = prev->next;
        prev->next = to_delete->next;
        
        // 更新尾节点
        if (index == list->length - 1) {
            list->tail = prev;
        }
    }
    
    free(to_delete->data);
    free(to_delete);
    list->length--;
    return 0;
}
// 修改指定位置元素
int list_set(List *list, size_t index, void *data) 
{
    if (!list || !data || index >= list->length) 
        return -1;
    
    ListNode *node = list->head;
    for (size_t i = 0; i < index; i++) {
        node = node->next;
    }
    
    memcpy(node->data, data, list->data_size);
    return 0;
}
// 获取指定位置元素
void* list_get(List *list, size_t index) {
    if (!list || index >= list->length) 
        return NULL;
    
    ListNode *node = list->head;
    for (size_t i = 0; i < index; i++) {
        node = node->next;
    }
    
    return node->data;
}

// 获取链表长度
size_t list_length(List *list) {
    return list ? list->length : 0;
}
void list_destroy(List *list) {
    if (!list) return;
    
    ListNode *current = list->head;
    while (current) {
        ListNode *next = current->next;
        free(current->data);
        free(current);
        current = next;
    }
    free(list);
}

2. h

#ifndef C_LIST_H
#define C_LIST_H

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

typedef struct ListNode 
{
    void *data;              
    struct ListNode *next;    

} ListNode;

typedef struct 
{
    ListNode *head;           
    ListNode *tail;           
    size_t data_size;        
    size_t length;  

} List;

List* list_create(size_t data_size);

// 在末尾添加元素
void list_append(List *list, void *data);

// 在指定位置插入元素
int list_insert(List *list, size_t index, void *data);

// 删除指定位置元素
int list_remove(List *list, size_t index);

// 修改指定位置元素
int list_set(List *list, size_t index, void *data);

// 获取指定位置元素
void* list_get(List *list, size_t index);

// 获取链表长度
size_t list_length(List *list);

// 销毁链表
void list_destroy(List *list);

#endif