单向列表的实现代码，以及注释解释笔记

*define a structure for linked lists*/
/*这里定义了一个list链表的类型*/

typedef struct List_
{
    int size;
    int (*match)(const void *key1,const void *key2);
    void (*destroy)(void *data);
    ListElmt *head;                      //head指向链表头结点的指针
    ListElmt *tail;                      //tail是指向链表中末尾的元素的指针
}List;



/*public interface*/

void list_init(List *list,void(*destroy)(void *data));      //链表初始化的，或者说创建的函数定义；
void list_destroy(List *list);                             // 链表数据结构的析构函数的定义；
int list_ins_next(List *list,ListElmt *element,const void *data);       //在list指定的的链表的element元素后面插入一个元素值data,if true return0;else return -1;
int list_rem_next(List *list,ListElmt *element,const void **data);   //在list指定的链表元素element元素后面移除一个元素值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

上面是单项列表的实现的头文件，定义了各种接口，以及元素结点，链表结构。

下面是单项列表实现的过程。

include "list.h"

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


//list_init
void list_init(List *list,void (*destroy)(void *data)){
         //初始化这个列表
         list->size=0;
         list->destroy =destroy;
         list->head=NULL;
         list->tail=NULL;


         return;
}



//list_destroy

void list_destroy(List *list){
          void *data;
                                         //下面移除掉链表里的每一个元素
          while(list_size(list)>0){
                 if(list_rem_next(list,NULL,(const void **)&data)==0 && list->destroy!=NULL){
                                   list->destroy(data);       //引用一个用户定义的函数去释放申请的内存空间
                                }
                          }
memset(list,0,sizeof(data));//没有运算被允许，但是要清空结构作为预处理
return;
}


//list_ins_next

int list_ins_next(List *list,ListElmt *element,const void *data){
              ListElmt *new_element;
              if((new_element=(ListElmt *)malloc(sizeof(ListElmt)))==NULL){
                return -1;             /*如果内存申请失败，则返回-1，这里把新结点的内存申请放在判断条件里进行了*/
              }
              new_element->data=(void*)data;   //把要插入的元素值赋给新的位置
              if(element==NULL){               //要插入位置的元素不为空的话
                if(list_size(list)==0){          //如果链表的大小为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->next;     //插入位置的元素的指针指向新插入的元素
                }
              }

              list->size++;       //插入成功以后，给链表的大小加上一
    return 0;
}



//list_rem_next
int list_rem_next(List *list,ListElmt *element,const void **data){
         ListElmt *old_element;

         if(list_size(list)==0){
              return -1;                        /*如果给定的列表为空表的话，直接返回-1*/
         }
         if(element==NULL)                      //如果要删除的位置为NULL的话，执行
             {
               *data=list->head->data;             //数据等于链表头的元素值
               old_element =list->head;             //把链表头元素地址给old_element
               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 main(void){
       printf("end");
       return 0;
}

最后面的main函数是为了，编译成功执行一下子。

如果是使用链表的话，尽量把实现的代码，放在单独的c文件里。