redis 源码学习之双端链表sdlist

sdlist主要作用

主要用在实现列表键、事务模块保存输入命令和服务器模块，订阅模块保存多个客户端等

sdlist的数据结构

Redis为双端链表的每一个节点定义了如下的结构体

// 链表节点定义
typedef struct listNode {
    struct listNode *prev;  // 指向前一个节点
    struct listNode *next;  // 指向后一个节点
    void *value; // 节点值
} listNode;

双端链表的迭代器的定义：
单向迭代器

typedef struct listIter {
    listNode *next;   // 当前迭代到的节点
    int direction;// 迭代的方向
} listIter;

对于direction参数，提供两个宏定义
#define AL_START_HEAD 0  // 从头到尾
#define AL_START_TAIL 1  // 从尾到头

双端链表的结构

 1. 双端链表结构
 */
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;

sdlist基本操作

2. sdlist创建
   sdlist提供了listCreate函数来创建一个空的链表
   创建成功返回链表，失败返回 NULL 。
   时间复杂度： T = O(1)

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. sdlist释放
   sdlist提供了listRelease函数来释放整个链表，以及链表中所有节点
   时间复杂度： T = O(N)

void listRelease(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);
        // 释放节点结构
        zfree(current);
        current = next;
    }
    // 释放链表结构
    zfree(list);
}

3. 插入节点
   sdlist提供了三个函数来完成向list中插入一个节点的功能
   1、 插入头节点

list *listAddNodeHead(list *list, void *value)
{
  listNode *node;
  // 为节点分配内存
  if ((node = zmalloc(sizeof(*node))) == NULL)
      return NULL;
  // 保存值指针
  node->value = value;
  // 添加节点到空链表
  if (list->len == 0) {
      list->head = list->tail = node;
      node->prev = node->next = NULL;
  // 添加节点到非空链表
  } else {
      node->prev = NULL;
      node->next = list->head;
      list->head->prev = node;
      list->head = node;
  }
  // 更新链表节点数
  list->len++;
  return list;
}

2、尾节点

list *listAddNodeTail(list *list, void *value)
{
    listNode *node;
    // 为新节点分配内存
    if ((node = zmalloc(sizeof(*node))) == NULL)
        return NULL;
    // 保存值指针
    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;
    }
    // 更新链表节点数
    list->len++;
    return list;
}

3、在任意位置插入节点

// 向任意位置插入节点
// 其中，old_node为插入位置
//      value为插入节点的值
//      after为0时表示插在old_node前面，为1时表示插在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) {  // 将新节点添加到给定节点之后
        node->prev = old_node;
        node->next = old_node->next;
        // 如果old_node为尾节点的话需要改变tail
        if (list->tail == old_node) {
            list->tail = node;
        }
    } else { // 将新节点添加到给定节点之前
        node->next = old_node;
        node->prev = old_node->prev;
        // 如果old_node为头节点的话需要改变head
        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;
}

4. 删除节点

void listDelNode(list *list, listNode *node)
{
    if (node->prev) // 删除节点不为头节点
        node->prev->next = node->next;
    else // 删除节点为头节点需要改变head的指向
        list->head = node->next;
    if (node->next)  // 删除节点不为尾节点
        node->next->prev = node->prev;
    else // 删除节点为尾节点需要改变tail的指向
        list->tail = node->prev;
    if (list->free) list->free(node->value); // 释放节点值
    zfree(node);  // 释放节点
    list->len--;
}

5. 迭代器相关的操作
   1、获取迭代器

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

2、释放迭代器
时间复杂度：T = O(1)

void listReleaseIterator(listIter *iter) {
    zfree(iter);
}

3、重置迭代器
时间复杂度：T = O(1)

void listRewind(list *list, listIter *li) {
    li->next = list->head;
    li->direction = AL_START_HEAD;
}
// 重置为逆向迭代器
void listRewindTail(list *list, listIter *li) {
    li->next = list->tail;
    li->direction = AL_START_TAIL;
}

4、获取下一个迭代器
时间复杂度：T = O(1)

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

6. 复制链表
   时间复杂度：T = O(N)

list *listDup(list *orig)
{
    list *copy;
    listIter *iter;
    listNode *node;
    // 创建新链表
    if ((copy = listCreate()) == NULL)
        return NULL;
    // 设置节点值处理函数
    copy->dup = orig->dup;
    copy->free = orig->free;
    copy->match = orig->match;
    // 迭代整个输入链表
    iter = listGetIterator(orig, AL_START_HEAD);
    while((node = listNext(iter)) != NULL) {
        void *value;
       // 复制节点值到新节点
        if (copy->dup) {
            value = copy->dup(node->value);
            if (value == NULL) {
                listRelease(copy);
                listReleaseIterator(iter);
                return NULL;
            }
        } else
            value = node->value;
        // 将节点添加到链表
        if (listAddNodeTail(copy, value) == NULL) {
            listRelease(copy);
            listReleaseIterator(iter);
            return NULL;
        }
    }
    // 释放迭代器
    listReleaseIterator(iter);
    // 返回副本
    return copy;
}

7. 查找函数
   时间复杂度：T=O(n)；
   1、根据给定节点值，在链表中查找该节点

listNode *listSearchKey(list *list, void *key)
{
    listIter *iter;
    listNode *node;
    // 迭代整个链表
    iter = listGetIterator(list, AL_START_HEAD);
    while((node = listNext(iter)) != NULL) {     
        // 对比
        if (list->match) {
            if (list->match(node->value, key)) {
                listReleaseIterator(iter);
                // 找到
                return node;
            }
        } else {
            if (key == node->value) {
                listReleaseIterator(iter);
                // 找到
                return node;
            }
        }
    } 
    listReleaseIterator(iter);
    // 未找到
    return NULL;
}

2、

listNode *listIndex(list *list, long index) {
    listNode *n;

    if (index < 0) {  // 序号为负，则倒序查找
        index = (-index)-1;
        n = list->tail;
        while(index-- && n) n = n->prev;
    } else { // 正序查找
        n = list->head;
        while(index-- && n) n = n->next;
    }
    return n;
}

8. 链表旋转函数
   旋转操作其实就是讲表尾节点移除，然后插入到表头，成为新的表头

void listRotate(list *list) {
    listNode *tail = list->tail;
    if (listLength(list) <= 1) return;
    // 取出表尾指针
    list->tail = tail->prev;
    list->tail->next = NULL;
    // 将其移动到表头并成为新的表头指针
    list->head->prev = tail;
    tail->prev = NULL;
    tail->next = list->head;
    list->head = tail;
}
``还封装了一些宏定义函数

```c
#define listLength(l) ((l)->len)  // 获取list长度
#define listFirst(l) ((l)->head)  // 获取list头节点指针
#define listLast(l) ((l)->tail)   // 获取list尾节点指针
#define listPrevNode(n) ((n)->prev)  // 获取当前节点前一个节点
#define listNextNode(n) ((n)->next)  // 获取当前节点后一个节点
#define listNodeValue(n) ((n)->value) // 获取当前节点的值
#define listSetDupMethod(l,m) ((l)->dup = (m))  // 设定节点值复制函数
#define listSetFreeMethod(l,m) ((l)->free = (m))  // 设定节点值释放函数
#define listSetMatchMethod(l,m) ((l)->match = (m))  // 设定节点值匹配函数
#define listGetDupMethod(l) ((l)->dup) // 获取节点值赋值函数
#define listGetFree(l) ((l)->free)  // 获取节点值释放函数
#define listGetMatchMethod(l) ((l)->match)  // 获取节点值匹配函数