简介:
Redis 的 List
对象的底层实现之一就是链表。C 语言本身没有链表这个数据结构的,所以 Redis 自己设计了一个链表数据结构,并且是一种双向链表linkedlist
格式存储,如下图:
作用:
双向链表linkedlist
,能在列表的头部(左边)或者尾部(右边)操作元素,它不仅可以作为链表使用,还可以在头部进行压入和弹出操作作为栈使用,在头部压入和尾部弹出作为队列或者阻塞队列使用;
节点ListNode:
包括头指针prev
,尾指针next
,当前的值value
,如下图所示。每个节点都有两个指针,既能从表头根据尾指针找到表尾,又能从表尾根据头指针prev找到表头,如果将他们连起来,就构成了双向链表。
链表节点结构
相关文件主要有 adlist.h
和 adlist.c
。
//定义链表节点的结构体
typedef struct listNode {
//前面一个节点的指针
struct listNode *prev;
//后面一个节点的指针
struct listNode *next;
//当前节点的值的指针 ,因为值的类型不确定
void *value;
} listNode;
Redis 在 listNode
结构体基础上又封装了 list 这个数据结构,这样操作起来会更方便,链表结构如下:
//定义链表,对链表节点的再封装
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;
双向链表的实现:
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;
定义链表,通过zmalloc
方法开辟内存空间,如果没有空闲空间,直接返回null,如果有空闲则进行赋值操作,首先定义头结点head和尾节点tail,最后返回结果list。
2)清空表
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的指针,首先定义当前节点current,使其指向头指针,定义len,使其等于list的长度。接着进行循环,每次len减一,定义新节点next,始终指向当前节点current的下一个节点,如果有值,则释放该节点,当前节点current后移,next节点同样后移。直到len为0,释放完所有节点,退出循环。最后赋值list的头节点head和尾节点tail为NULL,len为0。
注意:这边和SDS一样,清空并不是直接删除list,而是删除其数据,外层的list结构仍然存在。这其实上是惰性删除。
3)添加元素到表头
//添加一个元素到表头
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;
}
添加元素到表头,首先新建一个新节点node
,判断是否有内存分配,如果有,则继续,如果没有,则返回NULL,退出方法。这边新节点是用来存在输入参数中的value
的,所以需要内存。接着将新节点node的value值赋值为输入参数value。
4)添加元素到表尾
//添加元素到表尾
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;
}
添加元素到表尾,首先新建一个新节点node,判断是否有内存分配,如果有,则继续,如果没有,则返回NULL,退出方法。这边新节点是用来存在输入参数中的value的,所以需要内存。接着将新节点node的value值赋值为输入参数value。
5)插入
//在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的某个节点old_node的after(大于0为前面新增,小于0为后面新增)新增新值value,首先新建一个新节点node,判断是否有内存分配,如果有,则继续,如果没有,则返回NULL,退出方法。这边新节点是用来存在输入参数中的value的,所以需要内存。接着根据after的值确定是在节点old_node的前面新增数据,还是在节点old_node的后面新增数据,具体的是指针的调整。最后len加1,返回list。
6)删除
//从链表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--;
}
从list中删除节点node,如果该节点的前面存在节点,使其前面一个节点的next指针指向node后面一个节点的地址,其实就是跳过了node节点,如果该节点的前面不存在节点,则将list的头指针指向node的下一节点地址。同样的,如果该节点的后面存在节点,逻辑一样的。最后释放要删除的节点node内存,len减1。
链表的优势:
a、listNode 链表节点的结构里带有 prev
和 next
指针,获取某个节点的前置节点或后置节点的时间复杂度只需O(1)
,而且这两个指针都可以指向 NULL,所以链表是无环链表
;
b、list 结构因为提供了表头指针 head 和表尾节点 tail,所以获取链表的表头节点和表尾节点的时间复杂度只需O(1)
;
c、list 结构因为提供了链表节点数量 len,所以获取链表中的节点数量的时间复杂度只需O(1)
;
d、listNode 链表节使用 void* 指针保存节点值,并且可以通过 list 结构的 dup、free、match
函数指针为节点设置该节点类型特定的函数,因此链表节点可以保存各种不同类型的值;
链表的缺陷:
a、链表每个节点之间的内存都是不连续的,意味着**无法很好利用 CPU 缓存
。能很好利用 CPU 缓存的数据结构就是数组,因为数组的内存是连续的,这样就可以充分利用 CPU 缓存来加速访问
。
b、还有一点,保存一个链表节点的值都需要一个链表节点结构头的分配,内存开销较大
**。
补充内容:
a、Redis 3.0
的 List 对象在数据量比较少的情况下,会采用「压缩列表
」作为底层数据结构的实现,它的优势是节省内存空间,并且是内存紧凑型的数据结构;
b、压缩列表存在性能问题(具体什么问题,下面会说),所以 Redis 在 3.2 版本设计了新的数据结构 quicklist
,并将 List 对象的底层数据结构改由 quicklist 实现;
c、在 Redis 5.0
设计了新的数据结构 listpack
,沿用了压缩列表紧凑型的内存布局,最终在最新的 Redis 版本,将 Hash 对象和 Zset 对象的底层数据结构实现之一的压缩列表,替换成由 listpack 实现。
redis相关操作命令:
1)lpush
命令:加入一个元素到左边的头部
2)rpush
命令:加入一个元素到右边的底部
3)lpop
命令:从左边头部取出第一个元素
4)rpop
命令:从右边底部取出第一个元素
5)lrange
命令:从左边开始列出list的元素
6)llen
命令:获取list的长度。