(二) Redis中的链表List

最新推荐文章于 2023-06-19 23:13:57 发布
最新推荐文章于 2023-06-19 23:13:57 发布
阅读量151 收藏
点赞数
分类专栏： redis源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qw1356790/article/details/104503699
版权

1.1 链表
1.1.1 双端链表
Redis中的链表是双端链表。下图是双端链表的简易图。一般数据结构都是增删改查。
在这里插入图片描述

1.1.2 链表中的数据结构

  1. 节点数据结构
typedef  struct ListNode
{
	void * value;            //void * 可以接受任意类型的数据，
							 //也就是说链表中可以有不同类型的数据
	struct ListNode * prev;  //指向前一个节点的指针
	struct ListNode * next;  //指向后一个节点的指针
} ListNode ;
  1. 链表数据结构
typedef struct List
{
	ListNode * header;    // 表头节点
	ListNode * tailer;    //  表尾节点
	unsigned long length;   // 链表所包含的节点数量
	//下面这三个函数指针不知道啥时候用，等看到其他的c文件可能会更有启发
	void * (*Dup)(void * ptr);   // 节点值复制函数
	void  (*free)(void * ptr ;   // 节点值释放函数
	int (*match)(void * ptr,void * key);  // 节点值对比函数
	
} List ;
  1. 迭代器数据结构
typedef struct ListIter
{
	//将要迭代的节点
	ListNode * next ;
	// 方向
	int direction;
} ListIter ;

1.1.3 链表中的宏定义

  1. 宏定义能起到方便的作用（宏在预处理的时候会被替换）
  2. 但是，在redis源码List.h中定义的宏，很少使用到List.c中。可能是在其他的调用到这个List.h中会使用吧，目前只看到t_list.c中发现有使用，后面继续补充一下
  3. 宏定义的代码如下：
//List中的宏定义说白了就是对链表中的元素的的设置和获取
#define ListLength(l) ((l)->length)

#define ListFirst(l)((l)->header)

#define ListLast(l) ((l)->tailer)

#define ListPrevNode(n)((n)->prev)

#define ListNextNode(n)((n)->next)

#define ListNodeValue(n) ((n)->next)

#define ListSetDupMethod(l,m)((l)->dup = (m))

#define ListSetFreeMethod(l,m)((l)->free =(m))

#define ListSetMatchMathod(l,m) ((l)->match = (m))

#define ListGetDupMethod(l)((l)->dup)

#define ListGetFreeMethod(l)((l)->free)

#define ListGetMatchMathod(l) ((l)->match)

1.1.4 链表中的接口的设计

//这部分接口是我自己可以想到的
List * ListCreate(void);
void ListRelease(List *list);
List* ListAddNodeHead(List* list,void *value);
List* ListAddNodeTail(List * list ,void *value);
List * ListInsertNode(List *list ,ListNode* old_node ,void * value ,int after);
List * ListDeleteNode(List *list,ListNode * node);
ListIter * ListGetIterator(List * list,int direction);
ListNode * ListNext(ListIter * iter);
void ListReleaseIter(ListIter*iter);
ListNode * ListSeacherKey(List* list,void * key);
ListNode * ListIndex(List*list, long index);


//下面这部分接口是我不能想到的，目前还没有看这部分接口的源码
List *ListDup(List *orig);
void ListRewind(List *list, ListIter *li);
void ListRewindTail(List *list, ListIter *li);
void ListRotate(List *list);

1.2 函数实现
1.2.1 ListCreate函数

List * ListCreate(void)
{
	// 分配内存
	List * list = (List*)malloc(sizeof(List));
	if(List == NULL) return NULL;
	//初始化操作
	List->header = NULL;
	List->tailer = NULL;
	List->length = 0;
	List->dup = NULL;
	List->free = NULL;
	List->match = NULL;
	return List;
}
//上面这个函数的原型还可以是这样
int ListCreate(List ** list /*out*/);

1.2.2ListRelease函数

void ListRelease(List *list);
{
	unsigned long len;
	ListNode * cur = NULL;
	ListNode * next = NULL;
	//1.判断list 是否为空
	if(list == NULL) return ;
	//2.既然是链表，一般会有节点，所以要先释放节点的内存
	cur = list->header;
	len = list->len 
	while(len--)   //我写的 while(cur),应该没有区别
	{
		next = cur->next;
		if(list->free)
		{	//因为value 是void* 类型，void* 类型可能会指向一段堆上的空间
			list->free(cur->value);
		}
		free(cur);
		cur = next;
	}
	//3.释放链表的内存
	free(list);
}
//上面这个函数的原型还可以是这样
void ListRelease(List **list);  /*避免野指针的出现*/

1.2.3 头部ListAddNodeHead和尾部ListAddNodeTail插入数据

List* ListAddNodeHead(List* list /*in*/,void *value  /*in*/)
{
	ListNode * node = NULL;
	//1.判断参数
	if((list == NULL) || (value == NULL))
	{
		return NULL;
	}
	// 2.根据值创建一个节点出来
	
	node = (ListNode *) malloc(sizeof(ListNode));
	if(node == NULL) return NULL;
	//3.给节点赋值
	node->value = value; 
	//4.判断是否是空链表
	if(list->length == 0)
	{
		list->header = list->tailer = node;
		list->prev = list->next = NULL;
	}
	else{
		//注意画图
		node->next = list->header;
		node->prev = NULL;
		list->header->prev = node;
		list->header = node;
	}
		
	//容易忘记的点是插入数据的时候要len++;更新链表节点
	list->length++
	// 一定最后返回链表（容易忘记，就在写插入数据的前写上）
	return list;
}
//在节点头部插入和在节点尾部查入数据是类似的
List* ListAddNodeTail(List * list/*in*/ ,void *value/*in*/)
{
		ListNode * node = NULL;
	//1.判断参数
	if((list == NULL) || (value == NULL))
	{
		return NULL;
	}
	// 2.根据值创建一个节点出来
	
	node = (ListNode *) malloc(sizeof(ListNode));
	if(node == NULL) return NULL;
	//3.给节点赋值
	node->value = value; 
	//4.判断是否是空链表
	if(list->length == 0)
	{
		list->header = list->tailer = node;
		list->prev = list->next = NULL;
	}
	else{
		//注意画图
		node->next = NULL;
		node->prev = list->tailer;
		list->tailer->next = node;
		list->tailer = node;
	}
		
	//容易忘记的点是插入数据的时候要len++;更新链表节点
	list->length++
	// 一定最后返回链表（容易忘记，就在写插入数据的前写上）
	return list;
}

1.2.4 插入函数

//这个函数是正常插入数据，需要考虑多种情况、
//考虑在节点的前面还是后面插入数据
// 考虑old_node节点是否是头结点和尾节点
List * ListInsertNode(List *list ,ListNode* old_node ,void * value ,int after)
{
	ListNode * node = NULL;
	//创建一个节点
	node = (ListNode *)malloc(sizeof(ListNode));
	if(node == NULL) return NULL;
	//赋值
	node->value = value;
	if(after){
		node->next = old_node->next;
		node->prev = old_node;
		if(old_node == list->tailer)
		{
			list->tailer = node;
		}
	}
	else{
		node->next = old_node;
		node->prev = old_node->prev;
		if(old_node == list->header)
		{
			list->header =node;
		}
	}
	//下面这两个if，把所用的情况都包括了，包括后一个节点是NULL
	if(node->prev != NULL)
	{
		node->prev->next =node;
	}
	if(node->next != NULL){
		node->next->prev = node;
	}
	list->length++;
	return list;
}

1.2.5 删除节点函数


void  ListDeleteNode(List *list,ListNode * node)
{
	//
	if(node->next)  //说明node 不是尾节点
	{
		node->next->prev= node->prev;
	}
	else{   //说明node是尾节点
		list->tailer = node->prev;
	}
	if(node->prev)  //说明node 不是头节点
	{
		node->pre->next = node->next;
	}
	else{  //说明node 是头节点
		node->header = node->next;
	}
	//释放节点
	if(list->free) list->free(node->value);
	free(node);   
	//节点数量减1
	list->length--;
	
}

1.2.6迭代器相关函数

#define LIST_FROM_HEADER 1;
#define LIST_FROM_TAILER 0;

ListIter * ListGetIterator(List * list,int direction)
{
	ListIter  * iter = NULL;
	iter = (ListIter*)malloc(sizeof(ListIter));
	if(iter == NULL) return NULL;
	if(direction == LIST_FROM_HEADER)
	{
		iter->next = list->header;
		iter->direction = LIST_FROM_HEADER;
	}
	else{
		iter->next = list->tailer;
		iter->direction = LIST_FROM_TAILER;
	}
	return iter;
}
ListNode * ListNext(ListIter * iter)
{
	ListNode *cur;
	if(iter == NULL) return NULL;
	if(iter->direction == LIST_FROM_HEADER)
	{
		cur = iter->next;
		iter->next = cur->next;		
	}
	else{
		cur = iter->next;
		iter->next = cur->prev;	
	}

	return cur;
	
}
void ListReleaseIter(ListIter*iter)
{
	free(iter) ;
}

1.2.7 查找节点函数

ListNode * ListSeacherKey(List* list,void * key)
{
	ListNode * node = NULL;
	ListIter * iter = ListGetIterator(list,LIST_FROM_HEADER);
	while((node = ListNext(iter)) != NULL)
	{
		if(list->match){
			if(list->match(node->value,key)){
				ListReleaseIter(iter);
				return node;
			}
		}
		else{
			if(node->value == key){
				ListReleaseIter(iter);
				return node;
			}
		}
	}
	ListReleaseIter(iter);
	return NULL;
}

1.2.7 查找索引函数

ListNode * ListIndex(List*list, long index)
{
	
	ListNode * node;
	if(index < 0)  // 如果索引为负数，从表尾开始查找
	{
		index = (-index) -1;
		node->list->tailer;
		while((index--) && node)
		{
			n = n->prev;
		}
	}
	else{   // 如果索引为正数，从表头开始查找
		node = list->header;
		while(index-- && n) n =n->next;
	}
	return node;
}

参考一 ： redis源码
参考二： 黄健宏 Redis设计与实现
如有侵权：请联系邮箱 1986005934@qq.com

海是倒过来的天001
关注
专栏目录
Redis源码阅读-list双向链表
weixin_45704279的博客
05-05 973
Redis源码阅读-list双向链表 ​ 链表提供了高效的节点重排能力，以及顺序节点访问方式，并且节点的删除，增加都很灵活方便，但是Redis使用的C语言并不内置这种数据结构，所以Redis在adlist文件中实现了list，list在Redis中的应用非常广泛，如列表键，发布与订阅，慢查询，监视器等功能都用到了链表，Redis服务器本身也是用list来保存多个客户端的状态信息。链表的实现在adlist.h,adlist.c文件中。 list本体的实现 ​ 可以看到list中定义了三个数据类型，节点类型li
秒懂Redis数据结构之链表
weixin_66896902的博客
08-19 678
redis中链表的实现是基于双向链表的，在双向链表的基础上，增加了链表头指针，链表尾节点，链表节点数量以及复制函数、释放函数、比较函数。但由于链表的内存开销较大，就有了压缩列表。......
redis list ( 链表 )
热门推荐
清晨一场梦
09-25 1万+
list类型其实就是一个双向链表。通过push,pop操作从链表的头部或者尾部添加删除元素。 这使得list既可以用作栈，也可以用作队列。 上进上出是 栈 ，特点：数据 先进后出 下进上出是 队列，特点：数据 先进先出 从时间复杂度的角度来看，Redis列表主要的特性就是支持时间常数的 插入和靠近头尾部元素的删除，即使是需要插入上百万的条目。 访问列表两端的元素是非常快的，但如果你试着...
Redis List链表类型详解
玛卡巴卡的博客
05-03 1493
作为一种常用的数据结构，链表内置在很多高级的编程语言里面， 因为 Redis 使用的 C 语言没有内置这种数据结构， 所有 Redis 构建了自己的链表实现。 Redis链表节点和链表的实现 typedef struct listNode { // 前置节点 struct listNode *prev; // 后置节点 struct listNode *next; // 节点的值 void *value } listNode; 多个 li...
redis中的list
jason的笔记
02-02 885
redis的list 实现在如下路径中 E:\redis-3.0-annotated-unstable\redis-3.0-annotated-unstable\src\adlist.h typedef struct listNode { struct listNode *prev; struct listNode *next; void *value; } list
rotate-list
qq_40722582的博客
09-07 116
https://www.nowcoder.com/practice/afbec6b9d4564c63b2c149ccc01c5678?tpId=46&tqId=29118&tPage=5&rp=5&ru=/ta/leetcode&qru=/ta/leetcode/question-ranking 题目连题意都说不清楚，坑。。其实题意就是(假设链表的长度为n...
rotate_list（旋转链表）
apt1203JN的博客
08-09 355
题目描述 Given a list, rotate the list to the right by k places, where k is non-negative. 给定一个链表，将链表向右旋转k个位置，其中k是非负的。 For example: Given1-&gt;2-&gt;3-&gt;4-&gt;5-&gt;NULLand k =2, return4-&g...
详解Redis中的双链表结构
01-19
Redis中双链表实现的基本结构： 1.节点结构 typedef struct listNode { struct listNode *prev; //前向节点 struct listNode *next; //后向节点 void *value; //该节点的值 } listNode; 2.双向链表结构 ...
Redis Hash和List常用命令
weixin_31323635的博客
03-25 785
Redis Hash和List常用命令 Hash 1. HSET 命令 127.0.0.1:6379> hset book history "story" (integer) 12. HSETNX 命令：为哈希表不存在的域设值 使用 HSETNX 命令当且仅当域 field 不存在时，将哈希表 key 中的 field 的值设置为 value。如果 field 已经存在，...
Redis list源码分析
最新发布
极客神殿
06-19 434
RedisList是一种基于双向链表实现的数据结构，其底层数据结构由两个指针指向前一个元素和后一个元素，以此构成一个双向链表。在Redis中，List提供了一系列的操作方法，例如添加元素、删除元素、获取元素等。
2.redis学习笔记：redis List底层数据实现（通用双端链表）
linux_player_c（系统&开发）
11-27 3440
redis List底层数据实现redis列表使用两种数据结构左为底层实现： 1.双端链表 2.压缩列表今天我们来介绍redis中的双端链表，在前边的数据结构章节中已经介绍了通用双端链表的实现，在redis数据库中，双端链表还被很多内部模块所应用： 1.事务模块使用双端链表依序保存输入的命令； 2.服务器模块使用双端链表来保存多个客户端； 3.订
Redis添加List
weixin_30273501的博客
06-30 738
　　　　StackExchange.Redis组件中未提供List<T>直接添加Redis.List的方法，需要手动循环加入。 　　　　 var cacheName = string.Format(GameSalesSystemConsts.CacheDistrbution,userId.ToString(), type.ToString()); var...
redis用list做消息队列
mingwulipo的博客
11-22 4493
leftPush消息入队，rightPop对应，消息出队。 rightPop(RedisConstant.MQ_LIST, 0L, TimeUnit.SECONDS)阻塞出队，0表示永久阻塞 生产消息服务 @Service public class RedisService { @Autowired private RedisTemplate<String, String&g...
redis 列表(List) （redis学习五）
dengjili的专栏
12-08 1546
字符串命令基本命令SET 命令Get 命令Getrange 命令Getset 命令Mget 命令Setex 命令Setnx（SET if Not eXists） 命令Setrange 命令Strlen 命令Mset 命令Msetnx 命令Psetex 命令Incr 命令Incrby 命令INCRBY 命令Incrbyfloat 命令Decr 命令Decrby 命令Append 命令 基本命令 SE...
redis五种(字符串、hash、list、set、zset)数据结构API使用介绍
weixin_42739916的博客
03-03 666
1、字符串：API使用 del key：O(1),删除以key为键的数据，并将值一并删除，删除成功返回删除条数，反之返回0， 可同时删除多个键值对:格式：del key1 key2 key3...删除成功返回删除条数，反之返回0。 get key：O(1)，获取以key为键的值，键存在则返回值，不存在返回null(nil)。 set key value：设置key值为value，无论k...
文章二 Redis设计与实现研读--Redis自定义listNode结构体,实现链表用于存储数据
xiongxianze的博客
08-31 448
链表和链表节点的实现 每个链表节点使用一个 adlist.h/listNode 结构来表示： typedef struct listNode { // 前置节点 struct listNode *prev; // 后置节点 struct listNode *next; // 节点的值 void *value; } listNode; 多个 listNode 可以通过 prev 和 next ...
java 读取redis list_java代码中 单表查询出的list集合 怎么读写到redis中
weixin_29328371的博客
02-27 1206
查询出来的结果集是返回一个List，然后你倒序添加数据到redis里面就可以了。// 返回一个数据库查询结果集，listList list = userService.getUserList();//倒序把数据放进去就好了，不然取出来的数据，跟你查询出来的结果数据是相反的for (int i = list.size() - 1; i >= 0; i--) {RedisPool.getClie...
Redis学习笔记——ListNode
weixin_33743880的博客
03-31 270
Redis定义了双向链表，用来存储列表键的值，还有其他的我不知的。双向链表的节点定义为： typedef struct listNode { // 前置节点 struct listNode *prev; // 后置节点 struct listNode *next; // 节点的值 vo...
Redis双链表深度解析：结构与操作
Redis中的双链表结构是Redis数据结构中的一个重要组成部分，用于实现如列表键（list keys）等功能。本文将详细解析Redis双链表的内部结构、API以及相关的操作方法。 首先，Redis中的双链表由`listNode`结构体表示...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值