从redis源码看数据结构（一）链表

最新推荐文章于 2024-08-22 10:22:39 发布
最新推荐文章于 2024-08-22 10:22:39 发布
阅读量503 收藏
点赞数
分类专栏： 春招 数据结构 Redis 文章标签： redis 链表 list 源码分析 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41922289/article/details/102692814
版权
春招 同时被 3 个专栏收录
53 篇文章 0 订阅
订阅专栏
数据结构
53 篇文章 4 订阅
订阅专栏
Redis
15 篇文章 2 订阅
订阅专栏

文章目录

从redis源码看数据结构（一）链表

作者今年大三，正在准备明年的春招，文章中有写得不对的，希望大家及时指出文章中的错误的地方，欢迎互粉，大家一起努力!

一，redis数据类型

redis的数据类型有5种：

  • 列表（list）
  • 哈希表（hash）
  • 集合（set）
  • 字符串（String）
  • 有序集合（zset）

二，redis底层列表实现

以下代码均是redis源码，我已经放到我的github上，有意者可以前往拉取

1.列表底层数据结构

关于redis列表底层实现在src/adlist.c，adlist.h

在这里插入图片描述

链表节点源码：

/*
 * 链表节点
 * 
 * 【从链表节点这个结构体可以看出，redis的链表的数据类型底层是一个双向链表的实现】
 */
typedef struct listNode {

    // 前驱节点
    struct listNode *prev;

    // 后继节点
    struct listNode *next;

    // 值
    void *value;

} listNode;

链表源码：

/*
 * 链表
 */
typedef struct list {

    // 表头指针
    listNode *head;

    // 表尾指针
    listNode *tail;

    // 节点数量
    unsigned long len;

    // 复制函数
    void *(*dup)(void *ptr);
    // 释放函数
    void (*free)(void *ptr);
    // 比对函数
    int (*match)(void *ptr, void *key);
} list;

链表迭代器：

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

    // 下一节点
    listNode *next;

    // 迭代方向
    int direction;

} listIter;

从以上列表节点源码中可以看出，redis列表底层是使用链表中的双向链表实现的。

本文是题目是从redis中看数据结构，所以，我们本文的重点还是放在数据结构的复习上，刚刚既然提到了链表，好，我们开始对链表来一个大体的复习

2.redis双向链表操作

新建链表
/*
 * 创建一个新列表
 *
 * 创建成功时返回列表，创建失败返回 NULL
 *
 * T = O(1)
 */
list *listCreate(void)
{
    struct list *list;

    // 为列表结构分配内存,创建失败返回null
    if ((list = zmalloc(sizeof(*list))) == NULL)
        return NULL;

    // 初始化属性
    //头结点和未节点均为null
    list->head = list->tail = NULL;
    //长度为0
    list->len = 0;
    list->dup = NULL;
    list->free = NULL;
    list->match = NULL;

    return list;
}
删除链表

删除链表就是从头结点开始，一个节点一个节点的释放内存

/*
 * 释放整个列表(以及列表包含的节点)
 *
 * T = O(N)，N 为列表的长度
 */
void listRelease(list *list)
{
    unsigned long len;
    listNode *current, *next;
    //当前节点
    current = list->head;
    //当前节点长度
    len = list->len;
    //遍历链表，一个节点一个节点的释放内存，直到长度为0
    while(len--) {
        next = current->next;
        // 如果列表有自带的 free 方法，那么先对节点值调用它
        if (list->free) list->free(current->value);
        // 之后再释放节点,zfree()是redis自己实现的内存释放函数
        zfree(current);
        current = next;
    }
    zfree(list);
}

​

添加结点
添加头结点

添加头结点可以总结为：

  • 1.新建并初始化节点
  • 2.建立新建节点和原头结点的指针指向关系
  • 3.重新指定头节点

在这里插入图片描述

/*
 * 新建一个给定 value 的节点，并将它加入到列表的头部
 *
 * 出错时，返回 NULL ，不执行动作。
 * 成功时，返回传入的列表
 *
 * T = O(1)
 */
list *listAddNodeHead(list *list, void *value)
{
    listNode *node;
    //先新建节点，新建失败返回null
    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;
        //后继指针指向头结点head
        node->next = list->head;
        //原头结点head的前驱节点指向新建节点node
        list->head->prev = node;
        //指向关系确定好后，指定新的头结点为node
        list->head = node;
    }
    //长度+1
    list->len++;
    //返回
    return list;
}
添加尾节点

添加尾节点可以总结为：

  • 1.新建并初始化节点
  • 2.建立新建节点和原尾结点的指针指向关系
  • 3.重新指定尾节点

在这里插入图片描述

/*
 * 新建一个包含给定 value 的节点，并将它加入到列表的表尾
 *
 * 出错时，返回 NULL ，不执行动作。
 * 成功时，返回传入的列表
 *
 * T = O(1)
 */
list *listAddNodeTail(list *list, void *value)
{
    listNode *node;
    //先新建节点，新建失败返回null
    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;
        //原链表的尾节点tail的后继节点指向新的尾节点，即新建节点
        list->tail->next = node;
        //指向关系明确后，指定新的尾节点为新建节点
        list->tail = node;
    }
    //长度+1
    list->len++;
    //返回
    return list;
}
在指定节点前或后插入节点
  • 1.新建并初始化节点
  • 2.判断指定节点是否是头尾节点
  • 3.如果是头尾节点就根据上文提到的流程走
  • 4.如果不是头尾节点则指定节点和新建节点建立好对应的指向关系

在这里插入图片描述

/*
 * 创建一个包含值 value 的节点
 * 并根据 after 参数的指示，将新节点插入到 old_node 的之前或者之后
 *
 * T = O(1)
 */
list *listInsertNode(list *list, listNode *old_node, void *value, int after) {
    listNode *node;
    //新建节点，创建节点出错则返回null
    if ((node = zmalloc(sizeof(*node))) == NULL)
        return NULL;
    //初始化节点value
    node->value = value;
    //根据 after 参数的指示，将新节点插入到 old_node 的之前或者之后
    if (after) {
        // 插入到 old_node 之后
        //则node的前驱指向old_node
        node->prev = old_node;
        //node的后继指针指向old_node的后继节点
        node->next = old_node->next;
        //如果old_node本来就是该链表的尾节点，则相当于node要称为该链表的新的尾节点
        if (list->tail == old_node) {
            list->tail = node;
        }
    } else {
        //逻辑差不多。就不多详细注释了
        // 插入到 old_node 之前
        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;
}
删除节点
删除给定节点
  • 判断给定节点是否是头尾节点，如果是则删除后重新指定后继或者前驱节点为新的头结点或者尾节点
  • 不是的话，则删除节点的前驱和后继节点建立起指向关系
/*
 * 释放列表中给定的节点
 * 清除节点私有值(private value)的工作由调用者完成
 *
 * T = O(1)
 */
void listDelNode(list *list, listNode *node)
{
    // 处理前驱节点的指针
    if (node->prev)
        node->prev->next = node->next;
    else
        //node是头结点，则直接删除头结点
        list->head = node->next;

    // 处理后继节点的指针
    if (node->next)
        node->next->prev = node->prev;
    else
        //node是尾结点，则直接删除头结点
        list->tail = node->prev;

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

    // 释放节点
    zfree(node);

    // 更新列表节点数量
    list->len--;
}
获取节点
通过索引获取节点
  • 1.redis中根据索引查找节点，索引可以是正数，也可以是负数
  • 2.正数从 0 开始计数，由表头开始；负数从 -1 开始计数，由表尾开始。
/*
 * 根据给定索引，返回列表中对应的节点
 *
 * 索引可以是正数，也可以是负数。
 * 正数从 0 开始计数，由表头开始；负数从 -1 开始计数，由表尾开始。
 *
 * 如果给定索引超出列表的返回，返回 NULL 。
 *
 * T = O(N)，N 为列表的长度
 */
listNode *listIndex(list *list, long index) {
    listNode *n;
    //如果索引是负数，
    if (index < 0) {
        //负数从 -1 开始计数，由表尾开始。
        index = (-index)-1;
        n = list->tail;
        //从表尾开始遍历
        while(index-- && n) n = n->prev;
    } else {
        //索引是整数，则从0开始计数
        n = list->head;
        //从表头开始遍历查找
        while(index-- && n) n = n->next;
    }
    //返回
    return n;
}
获取迭代器当前节点
/*
 * 返回迭代器的当前节点
 *
 * 可以使用 listDelNode() 删除当前节点，但是不可以删除其他节点。
 *
 * 函数要么返回当前节点，要么返回 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;
}

三，java链表实现

本文作者的目标是希望通过redis底层数据结构来进行相应的数据结构的复习，包括哈希表，链表，集合等，都会在后边更新，说完redis源码后，这一部分基本就是自己手动实现相关数据结构，可能文字描述并不多

1.单链表

单链表是由后继指针和数值域构成的

在这里插入图片描述

public class MyList {

    /**
     * 单链表实现
     */
    private static class Node{
        //后继指针
        private Node next;
        //数值域
        private int value;

        public Node(Node next, int value) {
            this.next = next;
            this.value = value;
        }

        public Node(int value){
            this(null,value);
        }

		//省略get set
    }
    //头结点
    private Node head;
    //节点数量
    private int size;

    public MyList() {
        head = null;
        size = 0;
    }
    
    //.....

添加节点

    /**
     * 头部添加节点
     * @param value
     */
    public void addFirst(int value){
        Node node = new Node(value);
        node.next = this.head;
        this.size++;
        this.head = node;
    }

    /**
     * 尾部添加节点
     * @param value
     */
    public void addLast(int value){
        add(this.size,value);
    }

    /**
     * 在指定索引下添加指定节点
     * @param index
     * @param value
     */
    public void add(int index,int value){
        if(index < 0 || index > this.size){
            throw new IllegalArgumentException("index greater list.size");
        } else if(index == 0){
            addFirst(value);
        }else{
            Node cur = this.head;
            for(int i = 0; i< index - 1;i++){
                cur = cur.next;
            }
            Node node = new Node(value);
            node.next = cur.next;
            cur.next = node;
            this.size++;
        }
    }

删除节点

    /**
     * 删除指定下标的链表元素
     * @param index
     */
    public void remove(int index){
        if(index < 0 || index > this.size){
            throw new IllegalArgumentException("index greater list.size");
        }else if(this.head == null){
            throw new IllegalArgumentException("list is null list");
        }else if(index == 0){
            //删除头结点
            Node deleteNode = this.head;
            //指定新的头结点
            this.head = deleteNode.next;
            deleteNode.next = null;
            this.size--;
        }else{
            //找出指定下标的节点
            Node cur = this.head;
            for(int i = 0;i < index - 1;i++){
                cur = cur.next;
            }
            Node deleteNode = cur.next;
            cur.next = deleteNode.next;
            deleteNode.next = null;
            this.size--;
        }
    }

判断是否包含指定节点

    /**
     * 判断是否包含指定节点
     * @param value
     * @return
     */
    public boolean contains(int value){
        Node cur = this.head;
        while(cur != null){
            if(cur.value == value){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

测试

    public static void main(String[] args) {
        MyList myList = new MyList();
        for(int i = 0;i < 5;i++){
            myList.addLast(i);
        }
        System.out.println(myList.size);
        System.out.println(myList.contains(5));
        System.out.println(myList.contains(2));
        myList.add(1,5);
        System.out.println(myList.contains(5));
        System.out.println(myList.head.value);
        myList.add(0,9);
        System.out.println(myList.head.value);
    }

在这里插入图片描述

2.双向链表

链表和节点结构

public class MyLinkedList {

    //头结点
    private Node head;
    //尾节点
    private Node tail;
    //节点数量
    private int size;

    /**
     * 节点类
     */
    private class Node{
        //前驱
        private Node pre;
        //后继
        private Node next;
        //数值域
        private int value;
        public Node(int value){
            this.value = value;
        }
        //省略get set
    }
    
    public MyLinkedList(){
        head = tail = null;
        size = 0;
    }
    //....

添加节点

    /**
     * 头部添加
     */
    public void addFirst(int value){
        Node node = new Node(value);
        Node head = this.head;
        this.head = node;
        if(head == null){
            this.tail = node;
        }else{
            head.pre = node;
            node.next = head;
        }
        this.size++;
    }

    /**
     * 尾部添加
     * @param value
     */
    public void addLast(int value){
        Node node = new Node(value);
        Node tail = this.tail;
        this.tail = node;
        if(this.head == null){
            this.head = node;
        }else{
            tail.next = node;
            node.pre = tail;
        }
        this.size++;
    }

    /**
     * 指定索引添加指定节点
     * @param index
     * @param value
     */
    public void add(int index,int value){
        if(index < 0 || index > this.size){
            throw new IllegalArgumentException("index greater list.size");
        }else if (index == this.size){
            addLast(value);
        }else if(index == 0){
            addFirst(value);
        }else{
            Node cur = this.head;
            for(int i = 0;i < index - 1;i++){
                cur = cur.next;
            }
            Node node = new Node(value);
            Node next = cur.next;
            cur.next = node;
            node.pre = cur;
            next.pre = node;
            node.next = next;
            this.size++;
        }
    }

删除节点

    public void removeFirst(){
        if(this.head == null){
            return;
        }
        Node deleteHead = this.head;
        this.head = deleteHead.next;
        deleteHead.next = null;
        this.size--;
    }

    public void removeLast(){
        if(this.tail == null){
            return;
        }
        Node deleteHead = this.tail;
        this.tail = deleteHead.pre;
        deleteHead.pre = null;
        this.size--;
    }


    /**
     * 删除指定下标的链表元素
     * @param index
     */
    public void remove(int index){
        if(index < 0 || index > this.size){
            throw new IllegalArgumentException("index greater list.size");
        }else if(this.head == null){
            throw new IllegalArgumentException("list is null list");
        }else if(index == 0){
            removeFirst();
        }else if(index == this.size){
            removeLast();
        }else{
            //找出指定下标的节点
            Node cur = this.head;
            for(int i = 0;i < index - 1;i++){
                cur = cur.next;
            }
            Node deleteNode = cur.next;
            Node next = deleteNode.next;
            cur.next = next;
            next.pre = cur;
            deleteNode.pre = null;
            deleteNode.next = null;
            this.size--;
        }
    }

测试

    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        for(int i = 0; i<5;i++){
            myLinkedList.addLast(i);
        }
        System.out.println(myLinkedList.contains(2));
        System.out.println(myLinkedList.head.value);
        System.out.println(myLinkedList.tail.value);
        myLinkedList.remove(3);
        System.out.println(myLinkedList.contains(3));
        myLinkedList.remove(0);
        System.out.println(myLinkedList.head.value);
    }

在这里插入图片描述

Kevin_cai09
关注
专栏目录
看看redis的数据结构你都知道哪些
weixin_62421895的博客
08-16 374
当将Redis用作缓存程序时，你也可以通过它命令中的信息，决定
Redis源码阅读-list双向链表
weixin_45704279的博客
05-05 985
Redis源码阅读-list双向链表 ​ 链表提供了高效的节点重排能力，以及顺序节点访问方式，并且节点的删除，增加都很灵活方便，但是Redis使用的C语言并不内置这种数据结构，所以Redis在adlist文件中实现了list，list在Redis中的应用非常广泛，如列表键，发布与订阅，慢查询，监视器等功能都用到了链表，Redis服务器本身也是用list来保存多个客户端的状态信息。链表的实现在adlist.h,adlist.c文件中。 list本体的实现 ​ 可以看到list中定义了三个数据类型，节点类型li
redis当中的链表处理
zhoucs86的博客
11-19 451
https://blog.csdn.net/men_wen/article/details/69215222   Redis源码剖析—链表结构 1. redis中的链表 在redis中链表的应用非常广泛，例如列表键的底层实现之一就是链表。而且，在redis中的链表结构被实现成为双向链表，因此，在头部和尾部进行的操作就会非常快。 通过列表键的命令感受一下双向链表：列表键命令详解 127.0....
【Redis】Redis 底层的数据结构（结合源码）
最新发布
秋玄的博客
08-22 1023
Redis 底层数据结构详解
Redis源码：Redis源码怎么查看、Redis源码查看顺序、Redis外部数据结构到Redis内部数据结构查看源码顺序、Redis KV存储方式都是基于dict
郝开的博客
08-08 1373
dictEntry的val可以不同数据结构类型，因此很乱，所以设计了redisObject统一管理不同类型的val数据结构，dictEntry的val指向redisObject，redisObject的*ptr指向对象实际的数据结构/ * dictEntry的val可以不同数据结构类型，因此很乱，所以设计了redisObject统一管理不同类型的val数据结构，dictEntry的val指向redisObject，.................................
Redis(1)——5种基本数据结构
WantFlyDaCheng的博客
02-29 426
一、Redis 简介"Redis is an open source (BSD licensed), in-memory data structure store, used a...
Redis源码解析-基本数据结构
CrazyRabbitttt
11-11 793
本文主要介绍了 Redis 基础数据结构中的 SDS、字典、IntSet、Object等，希望能够帮助到大家
redis源码分析教程之压缩链表ziplist详解
12-16
Redis中的压缩链表（ziplist）是其内部为了节省内存空间和提高数据存取效率而设计的一种高效数据结构。ziplist适用于存储小体积且数量不大的数据，如字符串、整数等，它通过一系列特殊编码的内存块组织数据，使得在...
最新redis底层数据结构之双向链表
eno_yang的博客
04-24 355
简介 双向链表是redis中数据类型List的底层数据结构之一，双向链表也是一种常见的数据结构，在redis中也是大同小异 主要包括三个元素分别为链表，节点，链表迭代器，其设计比较简单 api易懂 为了方便大家阅读 本文做了详细的源码介绍 。 性能优化分析 链表的双向指针prev和next，方便通过迭代器从头至尾或从尾至头遍历； 链表的头尾指针head和tail，对链表的头尾插入，以及头尾节点读取，高效地实现list的一些指令（如push 和pop相关指令） 链表的长度len，得计算链表长度的时间复杂度为
Redis源码剖析：RedisObject与数据结构
3. `ptr`：指向实际数据的指针，根据对象的类型和编码，这个指针可能指向一个字符串、链表、哈希表、整数值或其他数据结构。 4. `refcount`：引用计数，表示有多少个其他对象或结构引用了这个对象。当引用计数为0时...
redis基本数据结构的源码实现
u013264213的博客
08-31 285
redis是在业界常用的NoSQL数据库，它以简单，高效，支持丰富的数据结构而著称，下面就简单介绍下redis中各种数据结构的底层实现。 1.String string是redis中最基础的数据结构，redis是由c实现的，但是redis中的string却不是由char完成的，而是redis自定义了一种sds(Simple Dynamic String)的数据结构。sds的基本数据结构如下： 其...
如何阅读 Redis 源码？
~~ LINUX ~~
09-08 1082
在这篇文章中， 我将向大家介绍一种我认为比较合理的 Redis 源码阅读顺序， 希望可以给对 Redis 有兴趣并打算阅读 Redis 源码的朋友带来一点帮助。 第 1 步：阅读数据结构实现 刚开始阅读 Redis 源码的时候， 最好从数据结构的相关文件开始读起， 因为这些文件和 Redis 中的其他部分耦合最少， 并且这些文件所实现的数据结构在大部分算法书上都可以了解到， 所以从这些文件开始读是最轻松的、难度也是最低的。 下表列出了 Redis 源码中， 各个数据结构的实现文件： 文件
【Redis入门】内部数据结构源码剖析
白夜行
07-24 792
SDS1.定义SDS（simple dynamic string）即简单动态字符串，在Redis中并没有直接使用C语言传统的字符串表示（以空字符结尾的字符数组），而使用自己构造的SDS。2.源码（1）结构体sds.h/sdshdr的源码如下：/* * 保存字符串对象的结构 */ struct sdshdr { // buf 中已占用空间的长度 int len; // buf
Redis应用与原理(2) Redis数据结构 源码解析
whichard的博客
04-01 368
数据结构 内存寸土寸金，能省则省，Redis在这一部分的设计思路便是节约 简单的C字符串无法满足Redis的需求，开发者设计了数据结构Simple Dynamic String用于存取字符串。 struct sdshdr { unsigned int len; unsigned int free; char buf[]; }; 比起C字符串，SDS具有以下优点： 1）常数...
redis部分源码数据结构图解
anchorite
06-08 421
Redis底层数据结构图解，sds、ziplist、hashtable、linkedlist、quicklist（ziplist+linkedlist）、intset、skiplist
Redis源码剖析-链表list
harley的博客
07-31 465
Redis另一个基础的数据结构是链表，C并没有内置的链表结构，因此Redis自己实现了一个列表。除了链表键之外， 发布与订阅、慢查询、监视器等功能也用到了链表， Redis 服务器本身还使用链表来保存多个客户端的状态信息， 以及使用链表来构建客户端输出缓冲区。List结构双端链表结点定义如下：typedef struct listNode { struct listNode *prev; /
redis源码分析—基本数据结构
lemonrel的博客
11-15 196
redis中使用的数据结构有: dict 字典,就是个哈希表,实现和HashMap类似,不做阐述;不同的是在哈希表resize()的时候是分步执行的,后续篇幅再说明。 sds 很多项目都对自己的字符串进行了封装,作用类似于leveldb的slice。 linkedlist 双端链表，迭代器的实现是通过链表的pre和next实现的，是个BidirctionalIterator。代码中只实现了For...
Redis源码阅读(一)
Orange_pa的博客
10-09 589
redis源码解析
Redis源码剖析--源码结构解析
ZeeCoder
12-09 1828
找工作那会儿，看了黄建宏老师的《Redis设计与实现》，对redis的部分实现有了一个简明的认识。在面试过程中，redis确实成为了面试官考核我的一个亮点，恰好以后的工作又与redis有着千丝万缕的联系，于是就想趁着毕业前的这段时间把redis的源代码研究一下，为以后的工作打个良好的基础。 Redis简介redis全称REmote DIctionary Server，是一个由Salvatore S
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值