Redis 5.0源码学习（一）—— 双向链表

在介绍Redis的双向链表之前我们可以思考这样一个问题：用C语言设计一个链表并满足以下条件：

1. 链表可以存储任何数据类型
2. o(n)时间复杂度查找某一个节点
3. o(n)时间复杂度返回链表指定位置的节点，从前往后链表节点的索引是0,1,…；从后往前是-1,-2,…
4. o(1)时间复杂度在链表头、链表尾插入新节点
5. o(n)时间复杂度在链表指定位置插入新节点
6. 链表支持双向遍历

Redis 双向链表数据结构的相关实现

Redis实现了满足上述条件的一种数据结构list，涉及的源文件为adlist.h，adlist.c，我在学习的过程对源代码添加了中文注释。

链表定义

链表节点的定义：

typedef struct listNode {
    struct listNode *prev;
    struct listNode *next;
    void *value;
} listNode;

为了让链表可以存储各种类型的数据，所以每个节点存储的数据是void *类型的。

链表的定义：

typedef struct list {
    listNode *head;
    listNode *tail;
    void *(*dup)(void *ptr);    // 用来深拷贝结点的函数
    void (*free)(void *ptr);    // 用来释放listNode中value指向的值
    int (*match)(void *ptr, void *key); // 判断当前结点是否跟key是匹配的
    unsigned long len;	// 记录链表当前的长度
} list;

由于节点是将数据存储在void* value，只有用户知道value实际的数据类型，所以用户要定义三个函数：dup，free，match用来拷贝、销毁、查询节点。

链表迭代器：

typedef struct listIter {
    listNode *next;
    int direction;
} listIter;

由于要支持链表的双向遍历，所以需要用direction来记录当前迭代器的“迭代方向”

链表的创建

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;
}

链表的销毁

链表的销毁包含3部分：

1. 销毁节点上存储的数据
2. 销毁链表中的每个节点
3. 销毁链表自己

void listRelease(list *list)
{
    listEmpty(list);    // 销毁双向链表中的所有节点
    zfree(list);    // 销毁双向链表
}

void listEmpty(list *list)
{
    unsigned long len;
    listNode *current, *next;

    current = list->head;
    len = list->len;
    while(len--) {
        next = current->next;
        if (list->free) list->free(current->value); //调用free函数指针释放当前节点value指向的空间
        zfree(current); // 释放当前节点的空间
        current = next;
    }
    list->head = list->tail = NULL; // 将链表的头、尾置NULL
    list->len = 0;
}

链表的迭代器

由于是双向链表，所以迭代器有两个方向。因此，创建链表的迭代器时需要指定方向。

listIter *listGetIterator(list *list, int direction)
{
    listIter *iter;

    if ((iter = zmalloc(sizeof(*iter))) == NULL) return NULL;
    if (direction == AL_START_HEAD)
        iter->next = list->head;
    else
        iter->next = list->tail;
    iter->direction = direction;
    return iter;
}

获取迭代器的下一个元素

listNode *listNext(listIter *iter)
{
    listNode *current = iter->next;

    if (current != NULL) {
        if (iter->direction == AL_START_HEAD)
            iter->next = current->next;
        else
            iter->next = current->prev;
    }
    return current;
}

链表的插入

// 在链表list中old_node节点处插入一个新的节点，新节点的值为value指向的空间
// after为0时是在old_node的前面插入，否则是在old_node的后面插入
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) {    // after非0，在olde_node后面插入
        node->prev = old_node;
        node->next = old_node->next;    //  此处，old_node->next还没更新
        if (list->tail == old_node) {
            list->tail = node;
        }
    } else {    // 在old_node前面插入
        node->next = old_node;
        node->prev = old_node->prev;    // 此处，old_node->prev还没更新
        if (list->head == old_node) {
            list->head = node;
        }
    }
    if (node->prev != NULL) {
        node->prev->next = node;    // 更新old_node->next
    }
    if (node->next != NULL) {
        node->next->prev = node;    // 更新old_node->prev
    }
    list->len++;
    return list;
}

链表的查找

listNode *listSearchKey(list *list, void *key)
{
    listIter iter;
    listNode *node;

    listRewind(list, &iter);    //获取链表从头向尾的迭代器
    while((node = listNext(&iter)) != NULL) {
        if (list->match) {
            if (list->match(node->value, key)) {    // 如果定义了match函数，则用match函数判断当前结点是否是key对应的结点
                return node;
            }
        } else {
            if (key == node->value) {   // 如果没定义match函数，则直接将key跟value进行值比较
                return node;
            }
        }
    }
    return NULL;
}