c的双向链表

头文件

//
//  double_list.h
//  doublelist
//
//  Created by bikang on 16/8/29.
//  Copyright (c) 2016年 bikang. All rights reserved.
//

#ifndef __doublelist__double_list__
#define __doublelist__double_list__

#include <stdlib.h>

//定义基础的结构
typedef struct DListElmt_{
    void *data;
    struct DListElmt_ *next;
    struct DListElmt_ *pre;
}DListElmt;


//定义列表
typedef struct Dlist_{
    int size;//大小
    int (*match)(const void *key1,const void *key2);//比较,匹配
    void (*destroy)(void *data);//内存释放函数
    DListElmt *head;//头
    DListElmt *tail;//尾部
}DList;


//初始化
void list_init(DList *list,void(*destroy)(void *data));
//在element元素后插入一个元素，element不允许为空
int list_ins_next(DList *list, DListElmt *element,const void *data);
//在element元素前面插入一个元素,element不允许为空
int list_ins_pre(DList *list, DListElmt *element,const void *data);

//删除一个元素
int list_rem(DList *list,DListElmt *element, void **data);

//删除一个列表，删除列表里面存储的data
void list_destroy(DList *list);


//定义基础的宏，获取各种基础的数据：获取大小，头，尾部，判断是头，是尾，数据，下一个元素
#define dlist_size(list) ((list)->size)
#define dlist_head(list) ((list)->head)
#define dlist_tail(list) ((list)->tail)
#define dlist_is_head(list,element) ((element) == (list)->head?1:0)
#define dlist_is_tail(element) ((element)->next == NULL?1:0)
#define dlist_data(element)((element)->data)
#define dlist_next(element)((element)->next)
#define dlist_pre(element)((element)->pre)

#endif /* defined(__doublelist__double_list__) */

实现文件

//
//  double_list.c
//  doublelist
//
//  Created by bikang on 16/8/29.
//  Copyright (c) 2016年 bikang. All rights reserved.
//
#include <stdlib.h>
#include <string.h>

#include <stdio.h>


#include "double_list.h"

//初始化
void list_init(DList* list,void(*destroy)(void *data)){
    list->size = 0;
    list->destroy = destroy;
    list->head = list->tail = NULL;
    return;
}

//插入数据,在element之后
int list_ins_next(DList *list, DListElmt *element,const void *data){
    DListElmt *new_element;

    if(dlist_size(list) != 0 && element == NULL ){
        return -1;
    }

    if((new_element = malloc(sizeof(DListElmt))) == NULL) return -1;

    new_element->next = NULL;
    new_element->pre = NULL;
    new_element->data = (void*)data;

    //error
    if(dlist_size(list) == 0){
        list->head = new_element;
        list->tail = new_element;
    }else {
        new_element->next = element->next;
        new_element->pre = element;
        if (element->next == NULL) {
            list->tail = new_element;
        }else{
            element->next->pre = element;
        }
        element->next = new_element;
    }
    list->size ++;
    return 0;
}


//插入在数据之后
int list_ins_pre(DList *list, DListElmt *element,const void *data){
    DListElmt *new_element;

    if(dlist_size(list) != 0 && element == NULL ){
        return -1;
    }

    if((new_element = malloc(sizeof(DListElmt))) == NULL) return -1;

    new_element->next = NULL;
    new_element->pre = NULL;
    new_element->data = (void*)data;

    //error
    if(dlist_size(list) == 0){
        list->head = new_element;
        list->tail = new_element;
    }else {
        new_element->next = element;
        new_element->pre = element->pre;

        if(element->pre == NULL){
            list->head = new_element;
        }else{
            element->pre->next = new_element;
        }
        element->pre = new_element;
    }
    list->size++;
    return 0;
}

//删除一个元素
int list_rem(DList *list,DListElmt *element, void **data){
    if(dlist_size(list) == 0 || element == NULL ){
        return -1;
    }
    *data = element->data;
    if(element == list->head){
        list->head = element->next;
        if(list->head == NULL){
            list->tail = NULL;
        }else{
            list->head->pre = NULL;
        }
    }else{
        element->pre->next = element->next;
        if(element->next == NULL){
            list->tail = element->pre;
        }else{
            element->next->pre = element->pre;
        }
    }
    free(element);
    list->size--;
    return 0;
}

/**
 destroy data;
 **/
void list_destroy(DList *list){
    void *data;
#ifdef DEBUG_FREE
    int i=0;
#endif
    while( dlist_size(list) > 0 ){

        if(list_rem(list,dlist_tail(list),(void**)&data) == 0 && list->destroy != NULL){
            list->destroy(data);
#ifdef DEBUG_FREE
            i++;
            printf("free-->%d\n",i);
#endif
        }
    }
    return;
}

测试代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define ONE_MB (1024 * 1024)

#include "double_list.h"

typedef struct Info_{
    int id;
    long phone;
}Info;

//打印一个列表
void print_list_int(DList *list);
void print_list_info(DList *list);
void testFree();

int main(int argc, const char * argv[]) {
    DList *pdlist;
    pdlist = (DList *)malloc(sizeof(DList));
    list_init(pdlist,free);
    printf("pdlist->size:%d\n", pdlist->size );

    //insert
    Info *pi2 = (Info*)malloc(sizeof(Info));
    pi2->id = 123131;
    pi2->phone = 13012131231;
    list_ins_next(pdlist,NULL,(void*)pi2);


    Info *pi3 = (Info*)malloc(sizeof(Info));
    pi3->id = 5370569;
    pi3->phone = 18611080217;
    list_ins_pre(pdlist,dlist_tail(pdlist),(void*)pi3);

    Info *pi4 = (Info*)malloc(sizeof(Info));
    pi4->id = 2231313;
    pi4->phone = 18643521217;
    list_ins_next(pdlist,dlist_tail(pdlist),(void*)pi4);

    printf("pdlist->size:%d\n", pdlist->size );
    print_list_info(pdlist);

    //delete
    void **ppi = (void**)malloc(sizeof(Info));
    list_rem(pdlist, dlist_tail(pdlist), ppi);
    print_list_info(pdlist);

    //destroy
    list_destroy(pdlist);
    return 0;
}
void print_list_info(DList *list){
    if(dlist_size(list) == 0){
        printf("empty list\n");
        return;
    }
    DListElmt *pl;
    pl = dlist_head(list);
    int i;
    printf("#########start#############\n");
    for(i=0;i<dlist_size(list);i++){
        printf("id=%d,phone=%ld\n",((Info*)dlist_data(pl))->id,((Info*)dlist_data(pl))->phone);
        pl = pl->next;
    }
    printf("#########end#############\n");
}