redis源码学习_链表

redis的链表是双向链表，该链表不带头结点，具体如下：

主要总结一下adlist.c和adlist.h里面的关键结构体和函数。

链表节点结构如下：

 /*
  * 双端链表节点
  */
 typedef struct listNode {

     // 前置节点
     struct listNode *prev; //如果是list的头结点，则prev指向NULL

     // 后置节点
     struct listNode *next;//如果是list尾部结点，则next指向NULL

     // 节点的值
     void *value;

 } listNode;

链表结构如下：

 /*
  * 双端链表结构
  */
 typedef struct list {

     // 表头节点
     listNode *head;

     // 表尾节点
     listNode *tail;

     // 节点值复制函数
     void *(*dup)(void *ptr);

     // 节点值释放函数
     void (*free)(void *ptr);

     // 节点值对比函数
     int (*match)(void *ptr, void *key);

     // 链表所包含的节点数量，有了这个我们获得链表长度的时间复杂度就是O(1)了
     unsigned long len;

 } list;

链表迭代器的结构如下：

 /*
  * 双端链表迭代器
  */
 typedef struct listIter {

     // 当前迭代到的节点
     listNode *next;

     // 迭代的方向
     int direction; //取值AL_START_HEAD等

 } listIter;

里面涉及的函数中，增、删的比较简单，就是结构里面没有带头结点，所以需要单独判断一下头结点的特殊情况。另外对于尾节点的操作也需要考虑一下特殊情况。

listAddNodeHead：将一个包含给定值的新节点添加到给定链表的表头

 /* Add a new node to the list, to head, contaning the specified 'value'
  * pointer as value.
  *
  * On error, NULL is returned and no operation is performed (i.e. the
  * list remains unaltered).
  * On success the 'list' pointer you pass to the function is returned. */
 /*
  * 将一个包含有给定值指针 value 的新节点添加到链表的表头
  *
  * 如果为新节点分配内存出错，那么不执行任何动作，仅返回 NULL
  *
  * 如果执行成功，返回传入的链表指针
  *
  * T = O(1)
  */
 list *listAddNodeHead(list *list, void *value)
 {
     listNode *node;

     // 为节点分配内存
     if ((node = zmalloc(sizeof(*node))) == NULL)
         return NULL;

     // 保存值指针
     node->value = value;

     // 添加节点到空链表
     if (list->len == ) {
         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;
 }

listAddNodeTail：将一个包含给定值的新节点添加到给定链表的表尾

 /* Add a new node to the list, to tail, containing the specified 'value'
  * pointer as value.
  *
  * On error, NULL is returned and no operation is performed (i.e. the
  * list remains unaltered).
  * On success the 'list' pointer you pass to the function is returned. */
 /*
  * 将一个包含有给定值指针 value 的新节点添加到链表的表尾
  *
  * 如果为新节点分配内存出错，那么不执行任何动作，仅返回 NULL
  *
  * 如果执行成功，返回传入的链表指针
  *
  * T = O(1)
  */
 list *listAddNodeTail(list *list, void *value)
 {
     listNode *node;

     // 为新节点分配内存
     if ((node = zmalloc(sizeof(*node))) == NULL)
         return NULL;

     // 保存值指针
     node->value = value;

     // 目标链表为空
     if (list->len == ) {
         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;
 }

listInsertNode：将一个包含给定值的新节点添加到给定节点的之前或者之后

 /*
  * 创建一个包含值 value 的新节点，并将它插入到 old_node 的之前或之后
  *
  * 如果 after 为 0 ，将新节点插入到 old_node 之前。
  * 如果 after 为 1 ，将新节点插入到 old_node 之后。
  *
  * T = O(1)
  */
 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;
         // 给定节点是原表尾节点
         if (list->tail == old_node) {
             list->tail = node;
         }
     // 将新节点添加到给定节点之前
     } else {
         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;
 }

listDelNode：从链表中删除给定节点

 /* Remove the specified node from the specified list.
  * It's up to the caller to free the private value of the node.
  *
  * This function can't fail. */
 /*
  * 从链表 list 中删除给定节点 node
  *
  * 对节点私有值(private value of the node)的释放工作由调用者进行。
  *
  * T = O(1)
  */
 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;

     // 释放值
     if (list->free) list->free(node->value);

     // 释放节点
     zfree(node);

     // 链表数减一
     list->len--;
 }

listGetIterator：创建一个链表迭代器，并根据传入的direction来返回链表的头或尾节点

 /* Returns a list iterator 'iter'. After the initialization every
  * call to listNext() will return the next element of the list.
  *
  * This function can't fail. */
 /*
  * 为给定链表创建一个迭代器，
  * 之后每次对这个迭代器调用 listNext 都返回被迭代到的链表节点
  *
  * direction 参数决定了迭代器的迭代方向：
  *  AL_START_HEAD ：从表头向表尾迭代
  *  AL_START_TAIL ：从表尾想表头迭代
  *
  * T = O(1)
  */  //获取列表list的首部阶段或者尾部结点
 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;
 }

listNext：拿到下一个迭代器节点

 /*
  * 返回迭代器当前所指向的节点。
  *
  * 删除当前节点是允许的，但不能修改链表里的其他节点。
  *
  * 函数要么返回一个节点，要么返回 NULL ，常见的用法是：
  *
  * iter = listGetIterator(list,<direction>);
  * while ((node = listNext(iter)) != NULL) {
  *     doSomethingWith(listNodeValue(node));
  * }
  *
  * 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;
 }

前面说了那么多操作，其实就是为了把它们组合起来使用，比如下面这个函数，就是上面的综合体。

listDup：复制链表

 /* Duplicate the whole list. On out of memory NULL is returned.
  * On success a copy of the original list is returned.
  *
  * The 'Dup' method set with listSetDupMethod() function is used
  * to copy the node value. Otherwise the same pointer value of
  * the original node is used as value of the copied node.
  *
  * The original list both on success or error is never modified. */
 /*
  * 复制整个链表。
  *
  * 复制成功返回输入链表的副本，
  * 如果因为内存不足而造成复制失败，返回 NULL 。
  *
  * 如果链表有设置值复制函数 dup ，那么对值的复制将使用复制函数进行，
  * 否则，新节点将和旧节点共享同一个指针。
  *
  * 无论复制是成功还是失败，输入节点都不会修改。
  *
  * 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;
 }

最后再提一个旋转函数listRotate，也没有什么需要过多解释的。

 /* Rotate the list removing the tail node and inserting it to the head. */
 /*
  * 取出链表的表尾节点，并将它移动到表头，成为新的表头节点。
  *
  * T = O(1)
  */
 void listRotate(list *list) {
     listNode *tail = list->tail;

     if (listLength(list) <= ) return;

     /* Detach current tail */
     // 取出表尾节点
     list->tail = tail->prev;
     list->tail->next = NULL;

     /* Move it as head */
     // 插入到表头
     list->head->prev = tail;
     tail->prev = NULL;
     tail->next = list->head;
     list->head = tail;
 }

总体来说，链表的数据结构是属于比较简单的。