双向循环链表

头文件

//
//  c_double_list.h
//  cycle_doublelist
//
//  Created by bikang on 16/9/1.
//  Copyright (c) 2016年 bikang. All rights reserved.
//

#ifndef __cycle_doublelist__c_double_list__
#define __cycle_doublelist__c_double_list__

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

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


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


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

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

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


//定义基础的宏，获取各种基础的数据：获取大小，头，尾部，判断是头，是尾，数据，下一个元素
#define cdlist_size(list) ((list)->size)
#define cdlist_head(list) ((list)->head)
#define cdlist_is_head(list,element) ((element) == (list)->head?1:0)
#define cdlist_data(element)((element)->data)
#define cdlist_next(element)((element)->next)
#define cdlist_pre(element)((element)->pre)


#endif /* defined(__cycle_doublelist__c_double_list__) */

实现

//
//  c_double_list.c
//  cycle_doublelist
//
//  Created by bikang on 16/9/1.
//  Copyright (c) 2016年 bikang. All rights reserved.
//

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

//初始化
void list_init(CDList* list,void(*destroy)(void *data)){
    list->size = 0;
    list->destroy = destroy;
    list->head= NULL;
    return;
}
int list_ins_next(CDList *list, CDListElmt *element,const void *data){
    CDListElmt *new_element;
    if(cdlist_size(list) != 0 && element == NULL ){
        return -1;
    }
    if((new_element = malloc(sizeof(CDListElmt))) == NULL) return -1;

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

//在element元素前面插入一个元素,element不允许为空
int list_ins_pre(CDList *list, CDListElmt *element,const void *data){
    CDListElmt *new_element;
    if(cdlist_size(list) != 0 && element == NULL ){
        return -1;
    }
    if((new_element = malloc(sizeof(CDListElmt))) == NULL) return -1;

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

//删除一个元素
int list_rem(CDList *list,CDListElmt *element, void **data){
    CDListElmt *oldElement;
    if(cdlist_size(list) == 0) return -1;

    oldElement = element;
     *data = oldElement->data;
    if(cdlist_size(list) == 1){
        list->head = NULL;
    }else{
        if(element == list->head){
            list->head = element->next;
        }
        element->pre->next = element->next;
        element->next->pre = element->pre;
    }
    free(oldElement);
    list->size--;
    return 0;
}

//delete
void list_destroy(CDList *list){
    void *data;
    while(cdlist_size(list) > 0){
        if(list->destroy != NULL  && list_rem(list,cdlist_head(list),(void**)&data)==0){
            list->destroy(data);
        }
    }
    memset(list, 0, sizeof(CDListElmt));
    return;
}

测试代码

//
//  main.c
//  cycle_doublelist
//
//  Created by bikang on 16/9/1.
//  Copyright (c) 2016年 bikang. All rights reserved.
//

#include <stdio.h>

#include "c_double_list.h"

typedef struct Info_{
    int id;
    long phone;
}Info;
void print_list_info(CDList *list);


int main(int argc, const char * argv[]) {
    CDList *pdlist;
    pdlist = (CDList *)malloc(sizeof(CDList));
    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,pdlist->head,(void*)pi3);

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

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

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

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


    return 0;
}


void print_list_info(CDList *list){
    if(cdlist_size(list) == 0){
        printf("empty list\n");
        return;
    }
    CDListElmt *pl;
    pl = cdlist_head(list);
    int i;
    printf("#########start#############\n");
    for(i=0;i<cdlist_size(list);i++){
        printf("id=%d,phone=%ld\n",((Info*)cdlist_data(pl))->id,((Info*)cdlist_data(pl))->phone);
        pl = pl->next;
    }
    printf("#########end#############\n");
}