Redis源码学习（26），双端链表学习，adlist.c（一）

最新推荐文章于 2024-08-15 14:59:07 发布
最新推荐文章于 2024-08-15 14:59:07 发布
阅读量494 收藏
点赞数
分类专栏： Redis源码学习 文章标签： 链表 redis 学习 Redis源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kelinfeng16/article/details/124754810
版权

1 listCreate

1.1 方法说明

  创建一个双端链表。

1.2 方法源代码

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

1.3 方法理解

  1. 先声明一个双端链表的结构体指针。
  2. 为这个指针分配内存。
  3. 链表相关属性初始化。
  4. 返回链表指针。

2 listRelease

2.1 方法说明

  释放整个双端链表。

2.2 方法源代码

/* Free the whole list.
 *
 * This function can't fail. */
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);
}

2.3 方法理解

  1. 获取双端链表的头节点和链表的节点数量。
  2. 开始遍历链表节点。
  3. 如果链表存在释放函数，则调用释放函数。
  4. 释放当前节点内存。
  5. 释放整个链表。

3 listAddNodeHead

3.1 方法说明

  向链表头部添加一个节点。

3.2 方法源代码

/* Add a new node to the list, to head, containing the specified 'value'
 1. pointer as value.
 2.  3. On error, NULL is returned and no operation is performed (i.e. the
 4. list remains unaltered).
 5. On success the 'list' pointer you pass to the function is returned. */
list *listAddNodeHead(list *list, void *value)
{
    listNode *node;
	
	//分配内存
    if ((node = zmalloc(sizeof(*node))) == NULL)
        return NULL;
    
    //将值的指针赋值给节点的value属性
    node->value = value;
	
	//如果链表节点数量为0
	

    if (list->len == 0) {
        list->head = list->tail = node;//将链表头指针和尾指针都指向新节点
        node->prev = node->next = NULL;//将新节点的前指针和后指针都指向NULL
    }
    //如果链表包含节点
	else {
        node->prev = NULL;    //将新节点的前指针指向NULL
        node->next = list->head;//将新节点的后指针指向链表的原头节点
        list->head->prev = node;//将链表的原头节点的前指针指向新节点
        list->head = node;//将链表的头指针指向新的节点
    }
    list->len++;//链表的节点数量加1
    return list;
}

3.3 方法理解

  1. 创建一个新的链表节点。
  2. 将节点的值赋值给节点的value属性。
  3. 如果链表没有节点，则将链表的头尾指针指向新节点，并将新节点的前后指针指向NULL。
  4. 如果链表由节点，则将新节点的后指针指向原先的头节点，并将链表的头指针指向新的节点。
  5. 链表节点数量加1。

  如果对C语言指针不了解的同学，可能要去熟悉一下C语言有关指针相关的知识，要不然后面很多代码都是和指针相关，这里看似很多箭头其实大体意思就是把新加的节点放到链表的头部去，那么原先的头部节点肯定就不能再是头结点了，所以要调整相关节点和链表的指针。

4 listAddNodeTail

4.1 方法说明

  向链表尾部添加一个节点。

4.2 方法源代码

/* 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. */
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;//将新节点的后指针指向NULL
        list->tail->next = node;//将链表原尾节点的后指针指向新的节点
        list->tail = node;//将链表的尾指针指向新的节点
    }
    list->len++;
    return list;
}

4.3 方法理解

  这个方法和 listAddNodeHead 大致相同，如果链表没有节点那么它们的操作是一样的，有节点会调整尾节点和链表的相关指针，目的是为了让新节点成为新的尾节点，能理解 listAddNodeHead 方法的话，这个方法也是一样的。

5 listInsertNode

5.1 方法说明

  向链表中某个节点前面或者后面添加一个新的节点。

5.2 方法源代码

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;
        }
    }
	
	//如果新节点的前指针不是NULL
    if (node->prev != NULL) {
        node->prev->next = node;//将新节点前面的节点的后指针指向自己
    }
    if (node->next != NULL) {
        node->next->prev = node;//将新节点后面的节点的前指针指向自己
    }
    list->len++;
    return list;
}

5.3 方法理解

  这个方法也是添加新的节点，不过不同于之前的 listAddNodeHead 和 listAddNodeTail，前面两个方法是在头部和尾部添加节点也就是最多影响一个老的节点，但是这个方法是在链表中间添加节点所以可能会影响两个节点，所以需要调整前后被影响的节点让它们的前后指针能执行自己，新节点的前后指针也能指向它们。

  连续学习三个添加节点的方法，想必大家对这种链表添加节点的套路已经开始熟悉起来，无非就是调一调指针就好。

6 listDelNode

6.1 方法说明

  从链表中删除一个节点。

6.2 方法源代码

/* 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. */
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--;
}

6.3 方法理解

  这个方法其实和之前几个添加节点的方法核心逻辑差不多，都是调节指针，相当于一个逆向的操作过程，添加节点的时候是把前后节点和自己关联起来，删除节点的时候是把前后节点对自己解除关联，如果影响到了头尾节点的变化还要修改链表的头尾指针。

7 迭代器相关方法

7.1 方法说明

  迭代器主要是用来遍历链表的，包括listGetIterator、listReleaseIterator、listRewind、listRewindTail、listNext几个方法。

7.2 方法源代码

/* 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. */
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;
}

/* Release the iterator memory */
//释放链表迭代器
void listReleaseIterator(listIter *iter) {
    zfree(iter);
}

/* Create an iterator in the list private iterator structure */
//将迭代器重置为一个头部开始的迭代器
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;
}

//获取下一个节点
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;
}

7.3 方法理解

  这是有关于链表遍历的一系列方法，分别有 listGetIterator、listReleaseIterator、listRewind、listRewindTail、listNext。

  遍历的思路应该是先通过listGetIterator获取一个迭代器，然后调用 listNext 来获取当前的节点，并将迭代器的next属性更新为下一个节点，而遍历的方向就是通过迭代器里 direction 属性来控制，获取到下一个节点之后会将下一个节点重新更新到next属性中。

8 总结

  1. 链表中添加节点的方法有listAddNodeHead、listAddNodeTail、listInsertNode。
  2. 链表中删除节点的方法有listDelNode。
  3. 链表新增或者删除节点需要调整被影响节点的前后指针，如果还影响了头尾节点，则还需要调整链表的头尾指针。
  4. 链表遍历相关的迭代器方法有listGetIterator、listReleaseIterator、listRewind、listRewindTail。
  5. 链表遍历主要靠 listNext 方法来获取下一个节点。
无痕之意
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis1.3.6:redis 1.3.6源码学习记录
03-23
总之，Redis 1.3.6 的源码提供了丰富的学习资源，涵盖了内存管理、数据结构以及如何将它们优雅地集成到一个高性能数据库中的实践。通过深入研究这些组件，开发者不仅可以提升对 Redis 的理解，还能增强自己的编程...
list中create函数的讲解
weixin_61122826的博客
03-01 1446
create（）的功能应该包含为创建申请一块结构体所需的空间，并将其与原表尾连接。 typedef struct xvesheng { int xvehao; int score; char name[20]; struct xvesheng *next; } xvesheng;
Redis源码学习（27），双端链表在列表中的应用
无痕之意的博客
05-14 275
  前几天我们学习了双端链表的源代码，想必大家已经清楚了不少有关链表的操作，这个时候再回想一下之前我们学习的数据结构列表的代码，我们知道双端链表是实现列表的数据结构之一，所以源代码里有很多关于链表的操作，今天我们就来回顾下列表的源代码，并探索下双端链表在列表的中的应用，通过这次发现我们能对列表的源代码学习就更加深入了。   今天我们要学习的源代码涉了好几个文件，不过都是我们之前阅读过的，分别是t_list.c、adlist.h、adlist.c。 1 listCreate   listCreate 是双端链
Redis源码分析（三）双向链表-adlist
yudaichenydc的博客
11-04 432
Redis源码分析（三）双向链表-adlist）概述内存结构结构体内存图 概述 Redis中的list结构的数据结构是双向链表，双向链表也叫双链表，是链表的一种，每个数据结点中都有两个指针，分别指向直接后继和直接前驱。 优点：从双向链表中的任意一个结点开始，都可以很方便地访问前驱结点和后继结点。 缺点：相比较于单链表的删除、增加节点，操作略微复杂，而且在内存上，需要多分配一个指针存储空间。 内存结构 结构体 可以看到 typedef struct listNode { // 前置节点 st
一个创建单链表的程序
congchangping的专栏
09-04 441
麻烦大家给看看 程序有错误,大家帮忙看看哪里错了,谢谢!!!LinkList CreateList(LinkList &head) //顺序建表{ head=new Node; head->next=NULL; Node *q=head; int flag=1; while(flag) { int x; cin>>x; if(x!=0)
数据结构-单链表的一些基本操作
m0_61245168的博客
09-25 347
这里是一些单链表的基础操作，欢迎阅读！！
Redis 源码分析 2. 分析起步
04-26
根据提供的信息，我们可以深入探讨 Redis 源代码分析的相关知识点，特别是从给定的标题“Redis 源码分析 2. 分析起步”以及描述“Redis 的源码分析第二部分 By SinSay”中提取出的关键信息。 ### 1. Redis 源码概述...
redis键值数据库源码分析
02-05
adlist.c 用于对list的定义，它是个双向链表结构 dict.c 主要对于内存中的hash进行管理 sds.c 用于对字符串的定义 sparkline.c 一个拥有sample列表的序列 t_hash.c hash在Server/Client中的应答操作。主要通过redis...
redis:Redis键值数据库源码注释
03-23
Redis 3.0源码注释 本项目是注释版的Redis 3.0源码，原始代码来自： : 。...双端链表数据结构的实现。 ae.c ， ae.h ， ae_epoll.c ， ae_evport.c ， ae_kqueue.c ， ae_select.c 事件处理器，以及各
Redis源代码分析.pdf
09-13
链表是Redis中最基本的数据结构，由adlist.h和adlist.c定义。基本数据结构listNode是最基本的结构，标示链表中的一个结点。结点有向前(next)和向后(prev)两个指针，链表是双向链表。保存的值是void*类型。 链表通过...
快速开发平台CreateList的用法
weixin_33785108的博客
10-29 822
用CreateList，可以创建一个List<Object>对象，在平台中，可以当数组效果使用，实现数组功能。代码如下：dimlist=CreateList() list.Add("张三") list.Add(1) list.Add("李四") foreachainlist msgbox(cstr(a)) nextList常用的用法如下...
restful ListCreateAPIView 类简单使用
dandanfengyun的博客
12-03 4455
序列化器Serializer 视图函数views from rest_framework.generics import ListCreateAPIView class PoemFourAPI(ListCreateAPIView): poems = Poem.objects.all() queryset = poems serializer_class = PoemNe...
Redis学习（二）——链表
smy166153的博客
06-20 257
文章目录一、链表的结构二、链表的API三、链表api源码1.listCreate2.listRelease3.listAddNodeHead4.listAddNodeTail5.listInsertNode6.listDelNode7.listGetIterator8.listReleaseItertor9.listRewind10.listRewindTail11.listNext12.listDup13.listSearchKey14.listIndex15.listRotate 一、链表的结构 typ
ListCreateAPIView,RetrieveUpdateDestroyAPIView
jiang_xiaoo24的博客
03-20 1348
from snippets.models import Snippet from snippets.serializers import SnippetSerializer from rest_framework import generics class SnippetList(generics.ListCreateAPIView): queryset = Snippet.obje...
List集合的几种创建方式
zsx18273117003的博客
11-15 8517
package com.zsx.test; import com.google.common.collect.Lists; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import java.util.ArrayList; import java.util.Arrays; impor...
单链表的创建算法
热门推荐
火雨(Nick)
03-26 5万+
单链表的创建算法        当一个序列中只含有指向它的后继结点的链接时，就称该链表为单链表。        单链表的示意图如下：                                                   Head指针为单链表的头指针，单链表L：L既是单链表的名字，也是其头指针。链表中的最后一个结点的指针域定义为空指针(NULL)。       单链表
链表创建（create_list)与遍历（travese_list)
qq_41783512的博客
11-08 5594
链表创建（create_list)与遍历（travese_list) 《数据结构》研究的主要是对数据的存储问题，而链表作为线性存储的一个重要方式，如何通过c语言来实现对链表的操作（下面的代码主要是创建链表以及如何遍历输出）是学习中的一个重点和难点。 代码部分： #include<stdio.h> #include<malloc.h> #include<stdli...
Redis常见的数据类型和应用场景
最新发布
z3551906947的博客
08-15 291
Redis（Remote Dictionary Server）是一个开源的高性能键值数据库，以其内存中数据存储、支持数据持久化、丰富的数据结构和原子操作而闻名。它通常用作数据库、缓存和消息队列系统。String类型是Redis中最基础的数据结构，它提供了简单的key-value存储功能。其中，key是数据的唯一标识符，而value可以是字符串或者数字。List类型在Redis中是一个双向链表结构，它可以存储一系列的字符串元素，元素在链表中有序，并且可以支持从链表的头部或尾部插入或删除元素。
第2章 NoSQL 之 Redis 集群
Shandy_stark223的博客
08-12 317
Redis 集群是一个提供在多个 Redis 间节点间共享数据的程序集Redis 集群并不支持处理多个 keys 的命令，因为这需要在不同的节点间移动数据，从而达不到像Redis那样的性能，在高负载的情况下可能会导致不可预料的错误Redis 集群通过分区来提供一定程度的可用性，在实际环境中当某个节点宕机或者不可达的情况下可继续处理命令。
Redis源码深度解析：关键数据结构与功能探讨
- 链表（adlist.h/adlist.c）：Redis的核心数据结构之一，采用双向链表实现，每个链表节点（listNode）包含前驱（prev）和后继（next）指针，以及存储值的void*指针。链表提供了头（head）和尾（tail）操作，便于在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值