Redis的双向链表一文全知道

为什么要从Redis源码分析

//定义链表节点的结构体 
typedef struct listNode {
	//前面一个节点的指针 
    struct listNode *prev;
    //后面一个节点的指针 
    struct listNode *next;
    //当前节点的值的指针 ，因为值的类型不确定 
    void *value;
} listNode;复制代码

//定义链表，对链表节点的再封装 
typedef struct list {
    listNode *head;//头指针 
    listNode *tail;//尾指针 
    void *(*dup)(void *ptr);//节点拷贝函数 
    void (*free)(void *ptr);//释放节点值函数 
    int (*match)(void *ptr, void *key);//判断两个节点是否相等函数 
    unsigned long len;//链表长度 
} list;复制代码

//创建一个表头，返回值是链表结构的指针 
list *listCreate(void)
{
    struct list *list;
    //尝试分配空间
    if ((list = zmalloc(sizeof(*list))) == NULL)
        return NULL;
    //相关属性赋值
    list->head = list->tail = NULL;
    list->len = 0;
    list->dup = NULL;
    list->free = NULL;
    list->match = NULL;
    //最终结果返回
    return list;
} 
复制代码

void listEmpty(list *list)
{
    unsigned long len;
    //定义两个节点指针current和next
    listNode *current, *next;
    //当前节点指针current指向list的头节点位置，即list的第一个数据
    current = list->head;
    //len为list的长度
    len = list->len;
    //开始循环，每次len减1
    while(len--) {
        //先让下一个指针指向下一个节点，因为底下直接释放当前节点，如果不在此处复制，底下就获取不到了
        next = current->next;
        //释放当前节点的值
        if (list->free) list->free(current->value);
        //释放当前节点
        zfree(current);
        //当前节点等于刚才的下一个节点next，即开始往后移，开始下一轮循环
        current = next;
    }
    //释放完给头指针head,尾指针tail赋值为NULL
    list->head = list->tail = NULL;
    //len赋值0
    list->len = 0;
}复制代码

//添加一个元素到表头 
list *listAddNodeHead(list *list, void *value)
{
    listNode *node;

    if ((node = zmalloc(sizeof(*node))) == NULL)
        return NULL;
    node->value = value;//为当前节点赋值 
    //如果当前list为空 
    if (list->len == 0) {
        list->head = list->tail = node;//头尾指针都指向改节点 
        node->prev = node->next = NULL;//当前节点的头尾指针都为null 
    } else {//如果当前list不为空 
        node->prev = NULL;//新节点的头指针为null 
        node->next = list->head;//新节点的尾指针指向原来的尾指针 
        list->head->prev = node;//原来的第一个节点的头指针指向新节点 
        list->head = node;//链表的头指针指向新节点 
    }
    list->len++;//list长度+1 
    return list;
}复制代码

//添加元素到表尾
list *listAddNodeTail(list *list, void *value)
{
    //新建节点node
    listNode *node;
    //尝试分配内存
    if ((node = zmalloc(sizeof(*node))) == NULL)
        return NULL;
    //为新节点node赋值
    node->value = value;
    //调整指针
    if (list->len == 0) {
        list->head = list->tail = node;
        node->prev = node->next = NULL;
    } else {
        node->prev = list->tail;
        node->next = NULL;
        list->tail->next = node;
        list->tail = node;
    }
    //len加1
    list->len++;
    return list;
} 复制代码

插入

为list的某个节点old_node的after（大于0为前面新增，小于0为后面新增）新增新值value，首先新建一个新节点node，判断是否有内存分配，如果有，则继续，如果没有，则返回NULL，退出方法。这边新节点是用来存在输入参数中的value的，所以需要内存。接着根据after的值确定是在节点old_node的前面新增数据，还是在节点old_node的后面新增数据，具体的是指针的调整。最后len加1，返回list。

//在list的某个位置old_node的after(前后)插入value值 
list *listInsertNode(list *list, listNode *old_node, void *value, int after) {
    listNode *node;

    if ((node = zmalloc(sizeof(*node))) == NULL)
        return NULL;
    node->value = value;
    if (after) {//大于0
        node->prev = old_node;
        node->next = old_node->next;
        if (list->tail == old_node) {
            list->tail = node;
        }
    } else {//小于0
        node->next = old_node;
        node->prev = old_node->prev;
        if (list->head == old_node) {
            list->head = node;
        }
    }
    if (node->prev != NULL) {
        node->prev->next = node;
    }
    if (node->next != NULL) {
        node->next->prev = node;
    }
    list->len++;
    return list;
}复制代码

删除

从list中删除节点node，如果该节点的前面存在节点，使其前面一个节点的next指针指向node后面一个节点的地址，其实就是跳过了node节点，如果该节点的前面不存在节点，则将list的头指针指向node的下一节点地址。同样的，如果该节点的后面存在节点，逻辑一样的。最后释放要删除的节点node内存，len减1。

//从链表list中删除某个节点node 
void listDelNode(list *list, listNode *node)
{
	//如果该节点的前面存在节点 
    if (node->prev)
        node->prev->next = node->next;
    else
        list->head = node->next;
    //如果该节点的前面存在节点 
   if (node->next)
        node->next->prev = node->prev;
    else
        list->tail = node->prev;
    //释放当前节点node的值
    if (list->free) list->free(node->value);
    //释放内存 
    zfree(node);
     //len-1 
    list->len--;
}复制代码