算法精讲链表的定义

struct Node{
   int data;
   Node *next;  
};

//元素
typedef struct ListElmt_ {
    void *data;
    struct ListElmt_ *next;
} ListElmt;

//列表
typedef struct List_{
    int size;
    int (*math)(const void *key1, const void *key2);
    void (*destroy)(void *data);
    ListElmt *head;
    ListElmt *tail;
} List;

#ifndef list_h
#define list_h

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

/**
 structure for linked list elements.
 */
typedef struct ListElmt_ {
    void *data;
    struct ListElmt_ *next;
} ListElmt;


/**
 structure for linked lists.
 */
typedef struct List_{
    int size;
    int (*math)(const void *key1, const void *key2);
    void (*destroy)(void *data);
    ListElmt *head;
    ListElmt *tail;
} List;

void list_init(List *list, void (*destory)(void *data));
void list_destory(List *list);
int list_ins_next(List *list, ListElmt *element, const 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)->next == NULL ? 1: 0)
#define list_data(element) ((element)->data)
#define list_next(element) ((element)->next)

#endif /* list_h */

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

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

void list_destory(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_ins_next(List *list, ListElmt *element, const void *data) {
    ListElmt *new_element;
    //allocate storage for the element.
    if ((new_element = (ListElmt *)malloc(sizeof(ListElmt))) == NULL) {
        return -1;
    }
    //Insert the element into the list.
    new_element->data = (void *)data;
    if (element == NULL) {
        //Handle insertion at the head of the list.
        if (list_size(list) == 0) {
            list->tail = new_element;
        }
        new_element->next = list->head;
        list->head = new_element;
    }else {
        //Handle insertion somewhere other than at the head.
        if (element->next == NULL) {
            list->tail = new_element;
            new_element->next = element->next;
            element->next = new_element;
        }
    }
    //Adjust the size of the list to account for the inserted element.
    list->size++;
    return 0;
}

int list_rem_next(List *list, ListElmt *element, void **data) {
    ListElmt *old_element;
    //Do not allow removal from an empty list.
    if (list_size(list) == 0) {
        return -1;
    }
    //Remove the element from the list.
    if (element == NULL) {
        //Handler removal from the head of the list.
        *data = list->head->data;
        old_element = list->head;
        list->head = list->head->next;
        
        if (list_size(list) == 1) {
            list->tail = NULL;
        }
    }else {
        //Handle removal form somewhere other than the head.
        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 the storage allocated by the abstract datatype.
    free(old_element);
    
    //Adjust the size of the list to account for the removed element.
    list->size--;
    
    return 0;
}