单链表一（链表的实现）

头文件

#ifndef LIST_H
#define LIST_H

#include<stdlib.h>

/*定义链表元素结构*/
typedef struct ListElmt_{
    void *data;
    struct ListElmt_ *next;
}ListElmt;

/*定义链表结构*/
typedef struct List_{
    int size;
    int (*match)(const void *key1, const void *key2);
    void (*destroy)(void *data);
    ListElmt *head;
    ListElmt *tail;
}List;

/*定义接口*/

/*初始化链表*/
void list_init(List *list, void (*destroy)(void *data));
/*销毁链表*/
void list_destroy(List *list);
/*下一个元素*/
int list_ins_next(List *list, ListElmt *element, void *data);
/*删除下一个元素*/
int list_rem_next(List *list, ListElmt *element, void **data);

/*宏定义*/
#define list_size(list)((list)->size)
#define list_head(list)((list)->head)
#define list_tail(list)((list)->tail)
#define list_is_head(list, element)((element) == (list)->head ? 1 : 0)
#define list_is_tail(element)((element)->tail == NULL ? 1 : 0)
#define list_data(element)((element)->data)
#define list_next(element)((element)->next)

#endif

单链表实现..

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

#include "list.h"

void list_init(List *list, void (*destroy)(void *data)) {
    
    list->size = 0;
    list->destroy = destroy;
    list->head = NULL;
    list->tail = NULL;

    return;
}

void list_destroy(List *list) {
    /*指向被销毁的列表元素*/
    void *data;

    while(list_size(list) > 0) {
        /*每次都删除头*/
        if(list_rem_next(list, NULL, (void **)&data) ==0 && list->destroy != NULL) {
            /*如何处理被删除的函数由调用者传递的析构函数决定*/
            list->destroy(data);
        }
    }
    /*清空链表结构*/
    memset(list, 0, sizeof(List));
    return;
}

int list_rem_next(List *list, ListElmt *element, void **data) {

    ListElmt *old_element;
    
    if (list_size(list) == 0) {
        return -1;
    }
    /*删除头*/
    if (element == NULL) {
        *data = list->head->data;
        old_element = list->head;
        list->head = list->head->next;
         
        if (list_size(list) == 1) {
            list->tail == NULL;
        }
    } else {
        if (element->next == NULL) {
            return -1;
        }
        *data = element->next->data;
        old_element = element->next;
        element->next = element->next->next;

        if (element->next == NULL) {
            list->tail = element;
        }
    }

    free(old_element);

    list->size--;
    return 0;
} 

int list_ins_next(List *list, ListElmt *element, const void *data) {
    ListElmt *new_element;
    if((new_element = (ListElmt *)malloc(sizeof(ListElmt))) == NULL) {
        return -1;
    }
    new_element->data = (void *)data;
    /*插入头*/
    if (element == NULL) {
        if (list_size(list) == 0) {
            list->tail = new_element;
        }
        new_element->next = list->head;
        list->head = new_element;
    } else {
        if (element->next == NULL) {
            list->tail = new_element;
        }
        new_element->next = element->next;
        element->next = new_element;
    }
    
    list->size++;
 
    return 0;
}