数据结构：双向循环链表的c语言实现方法二

双向环链之0长度数组c实现方法

在上篇文章中我们使用void *data指针来指向我们需要保存数据的地址，需要用户指定这个data数据的大小，然后通过malloc这个大一个内存来存放数据。本文章将使用另一种方法来保存数据。

在c99中开始 支持了零长度的数组[0],我们都知道数组的名字代表的是首元素的地址，并且数组内的数据在内存中是连续的，所以我们可以用数组的形式来保存数据，单位为一个字节，可以用char类型的数组，但是数组的长度设置为多少好呢，设置的大了会浪费空间，设置小了担心不够用，所以最好的方法是你需要多大的空间就设置成多大。

在这里我们可以使用零长度的数组char data[0]来保存即将保存数据的首地址，然后再让用户传入需要多大的空间保存数据，我们就可以通过malloc来申请，结构图如下：

根据用户传入的数据大小使用malloc申请内存，这个零长度数组相当于占位符，用来告诉我们数据的起始地址，最后返回数据的时候返回 给用户 数据 的 首地址然后转化为自己的数据类型读取数据 就可以了。他与上一篇文章中的方法都可以实现双环链。这里就拿上一篇文章中的内容进行修改。更改完后的程序如下：
llist.h

#ifndef LLIST_H__
#define LLIST_H__

#define INSERT_FORWARD      0
#define INSERT_BACKWARD     1

typedef void (*llist_print)(const void *data);
typedef int (*llist_cmp)(const void *key,const void *data);


struct llist_node
{
    struct llist_node *prev;
    struct llist_node *next;
    char data[0];
};

typedef struct llist_head
{
    int size;
    struct llist_node head;
}llist;

// 创建一个链表，输入参数为链表内要存储的数据类型大小
// 返回值为初始化好的链表头指针，使用完后需要通过llist_destroy函数释放
llist *llist_create(int size);

// 向链表内增加一个节点
// 第一个参数为要操作的链表，第二个参数为插入方式，前插或者后插
// 第三个参数为要插入的数据
int llist_insert(llist *,int mode,const void *data);

// 删除链表中的一个节点
// 第一个参数为要操作的链表，第二个参数为删除内容的关键词
// 第三个为用户需要自己实现的比较函数
int llist_delete(llist *,const void *key,llist_cmp cmp);

// 删除链表中的一个节点并返回删除节点内的数据
// 第一个参数为要操作的链表，第二个参数为要删除并获取的节点内容的关键词 
// 第三个参数为用户需要自己实现的比较函数，第四个参数用于保存获取的数据
int llist_fetch(llist *,const void *key,llist_cmp cmp,void *data);

// 按条件查找链表中的数据
// 第一个参数为要操作的链表,第二个参数为要查询内容的关键词
// 第三个参数为需要用户自己实现的比较函数
int llist_find(llist *,const void *key,llist_cmp cmp,void *data);

// 打印链表中存放的数据
// 第一个参数为要操作的链表，第二个参数为打印函数实现，提供给用户了接口
// 该函数实际只是遍历函数，通过用户提供的函数打印数据
void llist_show(llist *,llist_print );


// 释放链表所占用的内存空间
void llist_destroy(llist *);
#endif

llist.c

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

llist *llist_create(int size)
{
    llist *new = NULL;
    // 给链表头分配空间
    new = malloc(sizeof(*new));
    if(new == NULL)
        return NULL;

    new->size = size;
    new->head.prev = &new->head;
    new->head.next = &new->head;

    return new;
}

int llist_insert(llist *list,int mode,const void *data)
{
    // 如果操作的链表为空就返回
    if(list == NULL)
        return -1;

    struct llist_node *new = NULL;

    new = malloc(sizeof(*new)+list->size);
    if(new == NULL)
        return -2;

    memcpy(new->data,data,list->size);

    if(mode == INSERT_FORWARD)
    {
        new->next = list->head.next;
        new->prev = &list->head;
    }
    else if(mode == INSERT_BACKWARD)
    {
        new->prev = list->head.prev;
        new->next = &list->head;
    }
    new->prev->next = new;
    new->next->prev = new;

    return 0;
}

static struct llist_node *__find(llist *list,const void *key,llist_cmp cmp)
{
    struct llist_node *cur = NULL;
    for(cur = list->head.next;cur != &list->head;cur = cur->next)
    {
        if(cmp(key,cur->data))
            return cur;
    }
    return cur;
}


int llist_fetch(llist *list,const void *key,llist_cmp cmp,void *data)
{
    struct llist_node *ret = __find(list,key,cmp);
    if(data == NULL)
        return -1;
    if(ret == &list->head)
        return -2;
    memcpy(data,ret->data,list->size);

    ret->prev->next = ret->next;
    ret->next->prev = ret->prev;

    free(ret);

    return 0;
}


int llist_delete(llist *list,const void *key,llist_cmp cmp)
{
    struct llist_node *ret = __find(list,key,cmp);
    if(ret == &list->head)
        return -1;
    ret->prev->next = ret->next;
    ret->next->prev = ret->prev;

    free(ret);

    return 0;
}


int llist_find(llist *list,const void *key,llist_cmp cmp,void *data)
{
    struct llist_node *ret = __find(list,key,cmp);
    if(ret == &list->head)
        return -1;
    if(data == NULL)
        return -2;
    memcpy(data,ret->data,list->size);

    return 0;
}

void llist_show(llist *list,llist_print func)
{
    struct llist_node *cur = NULL;
    for(cur = list->head.next;cur != &list->head;cur = cur->next)
        func(cur->data);
}

void llist_destroy(llist *list)
{
    struct llist_node *cur,*next;
    for(cur = list->head.next;cur != &list->head;cur = next)
    {
        next = cur->next;
        free(cur);
    }
    free(list);
}

Makefile

out:main.o llist.o
    $(CC) $^ -o $@

.PHONY:clean

clean:
    -rm -rf *.o out

main.c

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

struct student
{
    char name[20];
    int age;
    int id;
};


void student_print(const void *data)
{
    struct student std = *((struct student *)data);
    printf("name : %s\r\n",std.name);
    printf("age : %d\r\n",std.age);
    printf("id : %d\r\n",std.id);
}

int id_cmp(const void *key,const void *data)
{
    int id = *((int *)key);
    struct student std = *((struct student *)data);
    return !(id - std.id);
}

int main(int argc,char **argv)
{
    llist *head = NULL;
    head = llist_create(sizeof(struct student));
    if(head ==  NULL)
        exit(1);
    for(int i=0;i<10;i++)
    {
        struct student std;
        snprintf(std.name,sizeof(std.name),"student%d",i);
        std.age = i;
        std.id = i;
        llist_insert(head,INSERT_BACKWARD,&std);
    }


    llist_show(head,student_print);

    int id = 1;
    int id1 = 9;
    int id2 = 2;
    llist_delete(head,&id,id_cmp);
    llist_delete(head,&id1,id_cmp);
    llist_delete(head,&id2,id_cmp);

    llist_show(head,student_print);

    int id3 = 4;
    struct student temp={0};
    int err = llist_fetch(head,&id3,id_cmp,&temp);
    if(err != 0)
        printf("没有找到\r\n");
    else
    {
        printf("name : %s\r\n",temp.name);
        printf("age : %d\r\n",temp.age);
        printf("id : %d\r\n",temp.id);
    }

    err = llist_find(head,&id,id_cmp,&temp);
    if(err != 0)
        printf("没有找到\r\n");
    else
    {
        printf("name : %s\r\n",temp.name);
        printf("age : %d\r\n",temp.age);
        printf("id : %d\r\n",temp.id);
    }

    llist_show(head,student_print);

    llist_destroy(head);
    exit(0);
}