双端链表list的实现 | 自己实现Redis源代码(2)

最新推荐文章于 2024-09-27 00:37:50 发布
最新推荐文章于 2024-09-27 00:37:50 发布
阅读量142 收藏
点赞数
分类专栏： 造轮子 文章标签： 数据库开发 c++ Redis 链表 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40955287/article/details/88310267
版权

通过对《Redis设计与实现》一书的学习，我打算动手自己实现一份“Redis源代码”作为自己的学习记录。

对Redis感兴趣的同学可以查看我的另一篇文章 造个轮子 | 自己动手写一个Redis。

本章介绍的是Redis源代码中的双端链表list的实现。



双端链表list的实现


list的API

（1）创建一个不包含任何结点的新链表

list *listCreate(void);

（2）释放给定链表，以及链表中的所有结点

void listRelease(list *l);

（3）将一个包含给定值的新节点添加到给定链表的表头

list *listAddNodeHead(list *l, void *value);

（4）将一个包含给定值的新节点添加到给定链表的表尾

list *listAddNodeTail(list *l, void *value);

（5）将一个包含给定值的新节点添加到给定结点的之前或之后

list *listInsertNode(list *l, listNode *old_node, void *value, int after);

（6）从链表中删除给定结点

list *listDelNode(list *l, listNode *node);

（7）复制一个给定链表的副本

list *listDup(list *orig);

（8）查找并返回链表中包含给定值的结点

listNode *listSearchKey(list *l, void *key);

（9）返回链表在给定索引上的结点

listNode *listIndex(list *l, long index);

（10）将链表结点的表位结点弹出，然后将被弹出的结点插入到链表的表头，成为新的表头结点

void listRotate(list *l);



头文件

#ifndef __ADLIST_H__
#define __ADLIST_H__

//双端链表

//双端链表的结点
typedef struct listNode{
	struct listNode *prev;//指向点一个结点的指针
	struct listNode *next;//指向下一个结点的指针
	void *value;//结点存放的值
}listNode;

//链表
typedef struct list{
	listNode *head;//头结点
	listNode *tail;//尾结点
	int len;//链表的长度

	//用于实现多态链表所需的类型的特定函数
	//函数指针
	//用于复制链表结点所保存的值
	void *(*dup)(void *ptr);
	//用于释放链表结点所保存的值
	void (*free)(void *ptr);
	//用于对比
	int (*match)(void *ptr, void *key);
}list;

//定义对链表进行操作的宏
//获取链表长度
#define listLength(l) ((l)->len)
//获取链表的头结点
#define listFirst(l) ((l)->head)
//获取链表的尾结点
#define listLast(l) ((l)->tail)
//获取前一个结点
#define listPrevNode(n) ((n)->prev)
//获取下一个结点
#define listNextNode(n) ((n)->next)
//获取该结点的值
#define listNodeValue(n) ((n)->value)
//设置复制操作的函数指针
#define listSetDupMethod(l,m) ((l)->dup = (m))
//设置释放操作的函数指针
#define listSetFreeMethod(l,m) ((l)->free = (m))
//设置对比操作的函数指针
#define listSetMatchMethod(l,m) ((l)->match = (m))
//获取复制链表结点的函数指针
#define listGetDupMethod(l) ((l)->dup)
//获取释放链表结点的函数指针
#define listGetFree(l) ((l)->free)
//获取比较链表结点的函数指针
#define listGetMatchMethod(l) ((l)->match)

//创建一个不包含任何结点的新链表
list *listCreate(void);
//释放给定链表，以及链表中的所有结点
void listRelease(list *l);
//将一个包含给定值的新节点添加到给定链表的表头
list *listAddNodeHead(list *l, void *value);
//将一个包含给定值的新节点添加到给定链表的表尾
list *listAddNodeTail(list *l, void *value);
//将一个包含给定值的新节点添加到给定结点的之前或之后
list *listInsertNode(list *l, listNode *old_node, void *value, int after);
//从链表中删除给定结点
list *listDelNode(list *l, listNode *node);
//复制一个给定链表的副本
list *listDup(list *orig);
//查找并返回链表中包含给定值的结点
listNode *listSearchKey(list *l, void *key);
//返回链表在给定索引上的结点
listNode *listIndex(list *l, long index);
//将链表结点的表位结点弹出，然后将被弹出的结点插
//入到链表的表头，成为新的表头结点
void listRotate(list *l);

#endif



list API的实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "adlist.h"

//创建一个不包含任何结点的新链表
list *listCreate(void){
	list* l=(list*)malloc(sizeof(list));
	//没有结点
	l->head=NULL;
	l->tail=NULL;
	l->len=0;
	l->dup=NULL;
	l->free=NULL;
	l->match=NULL;
	return l;
}
//释放给定链表，以及链表中的所有结点
void listRelease(list *l){
	if(l==NULL){
		return ;
	}
	//没有head(没有结点)
	if(l->head==NULL){
		return ;
	}
	//保证了链表是有结点存在的
	//用来移动的指针，指向第一个结点
	listNode*temp=l->head;
	while(temp->next!=NULL){
		temp=temp->next;
		//使用链表对应释放value的free来释放value的值
		if(l->free!=NULL){
			l->free(temp->value);
		}else{
			printf("PIG Redis WARNING : List->free is not define.\n");
		}
		free(temp->prev);
	}
	free(temp);
	l->head=NULL;
	l->tail=NULL;
	free(l);
	l=NULL;
	return;
}


//将一个包含给定值的新节点添加到给定链表的表头
list *listAddNodeHead(list *l, void *value){
	if(l==NULL){
		printf("PIG Redis ERROR : List NULL.\n");
		return NULL;
	}
	//链表中没有结点
	if(l->head==NULL){
		l->head=(listNode*)malloc(sizeof(listNode));
		l->head->next=NULL;
		l->head->prev=NULL;
		//使用链表对应复制value的dup来复制value的值
		if(l->dup!=NULL){
			l->head->value=l->dup(value);
		}else{
			printf("PIG Redis WARNING : List->dup is not define.\n");
			l->head->value=value;
		}
/*		int *c=(int*)(l->head->value);
		printf("%d====\n",*c);*/
		l->len=1;
		//头尾指针都指向新的结点
		l->tail=l->head;
		return l;
	}else{
		listNode*newone=(listNode*)malloc(sizeof(listNode));
		//newone->value=value;
		//使用链表对应复制value的dup来复制value的值
		if(l->dup!=NULL){
			newone->value=l->dup(value);
		}else{
			printf("PIG Redis WARNING : List->dup is not define.\n");
			newone->value=value;
		}
/*		int *cc=(int*)(newone->value);
		printf("%d====\n",*cc);*/

		newone->next=l->head;
		l->head->prev=newone;
		//新节点设为头结点
		l->head=newone;
		newone->prev=NULL;
		l->len++;
		return l;
	}
}

//将一个包含给定值的新节点添加到给定链表的表尾
list *listAddNodeTail(list *l, void *value){
	if(l==NULL){
		printf("PIG Redis ERROR : List NULL.\n");
		return NULL;
	}
	//链表中没有结点
	if(l->head==NULL){
		l->head=(listNode*)malloc(sizeof(listNode));
		//l->head->value=value;
		//使用链表对应复制value的dup来复制value的值
		if(l->dup!=NULL){
			l->head->value=l->dup(value);
		}else{
			printf("PIG Redis WARNING : List->dup is not define.\n");
			l->head->value=value;
		}		
		l->head->next=NULL;
		l->head->prev=NULL;
		l->tail=l->head;
		l->len=1;
		return l;
	}else{
		listNode*temp=(listNode*)malloc(sizeof(listNode));
		//temp->value=value;
		//使用链表对应复制value的dup来复制value的值
		if(l->dup!=NULL){
			temp->value=l->dup(value);
		}else{
			printf("PIG Redis WARNING : List->dup is not define.\n");
			temp->value=value;
		}
		temp->next=NULL;
		temp->prev=l->tail;
		l->tail->next=temp;
		l->tail=temp;
		l->len++;
		return l;
	}
}

//将一个包含给定值的新节点添加到给定结点的之前或之后
//after为1表示之后，after为0表示之前
list *listInsertNode(list *l, listNode *old_node, void *value, int after){
	listNode *newone=(listNode*)malloc(sizeof(listNode));
	//newone->value=value;
	//使用链表对应复制value的dup来复制value的值
	if(l->dup!=NULL){
		newone->value=l->dup(value);
	}else{
		printf("PIG Redis WARNING : List->dup is not define.\n");
		newone->value=value;
	}
	l->len++;
	if(after){
		newone->next=old_node->next;
		newone->prev=old_node;
		old_node->next->prev=newone;
		old_node->next=newone;
		//检查原来的temp是否为tail
		if(l->tail==old_node){
			l->tail=newone;
		}
		return l;
	}else{
		newone->next=old_node;
		newone->prev=old_node->prev;
		old_node->prev->next=newone;
		old_node->prev=newone;
		//检查原来的temp是否为头结点
		if(l->head==old_node){
			l->head=newone;
		}
		return l;		
	}
}	

//从链表中删除给定结点
list *listDelNode(list *l, listNode *node){
	l->len--;
	//使用链表对应释放value的free来释放value的值
	if(l->free!=NULL){
		l->free(node->value);
	}else{
		printf("PIG Redis WARNING : List->free is not define.\n");
	}
	//要删除的是最后一个结点
	if(l->head==node&&l->tail==node){
		free(node);
		l->head=NULL;
		l->tail=NULL;
		return l;
	}else if(l->head==node){
		printf("head\n");
		l->head=node->next;
		l->head->prev=NULL;
		free(node);
		return l;
	}else if(l->tail==node){
		l->tail=node->prev;
		l->tail->next=NULL;
		free(node);
		return l;
	}
	node->prev->next=node->next;
	node->next->prev=node->prev;
	free(node);
	return l;
}

//复制一个给定链表的副本
list *listDup(list *orig){
	if(orig==NULL){
		return NULL;
	}
	//该链表没有结点
	if(orig->head==NULL){
		list*l=listCreate();
		return l;
	}else{
		list*l=listCreate();
		listNode*temp=orig->head;
		while(temp!=NULL){
			//向表尾插入
			l=listAddNodeTail(l,temp->value);
			temp=temp->next;
		}
		return l;
	}
}

//查找并返回链表中包含给定值的结点
listNode *listSearchKey(list *l, void *key){
	if(l==NULL){
		printf("PIG Redis ERROR : List NULL.\n");
		return NULL;
	//链表中没有结点
	}else if(l->head==NULL){
		printf("PIG Redis ERROR : List does't have nodes.\n");
		return NULL;
	}else{
		listNode*temp=l->head;
		//检查是否定义了比较value的函数
		if(l->match==NULL){
			printf("PIG Redis ERROR : List->match is not define.\n");
			return NULL;
		}
		//match函数当两者相等时返回1
		while(temp!=NULL&&!(l->match(key,temp->value))){
			temp=temp->next;
		}
		if(temp==NULL){
			printf("PIG Redis ERROR : List doesn't have this node.\n");
			return NULL;
		}else{
			return temp;
		}
	}
}	

//返回链表在给定索引上的结点,index从0开始
listNode *listIndex(list *l, long index){
	if(l==NULL){
		printf("PIG Redis ERROR : List NULL.\n");
		return NULL;
	}else if(l->head==NULL){
		printf("PIG Redis ERROR : List doesn't have node.\n");
		return NULL;
	}
	listNode*temp=l->head;
	for(int i=0;i<index&&temp!=NULL;i++){
		temp=temp->next;
	}
	if(temp==NULL){
		printf("PIG Redis ERROR : Subscript out of range.\n");
		return NULL;	
	}
	return temp;
}

//将链表结点的表尾结点弹出，然后将被弹出的结点插
//入到链表的表头，成为新的表头结点
void listRotate(list *l){
	if(l==NULL){
		printf("PIG Redis ERROR : List NULL.\n");
		return ;
	}else if(l->head==NULL){
		printf("PIG Redis ERROR : List doesn't have node.\n");
		return ;
	}else if(l->head==l->tail){
		printf("PIG Redis ERROR : List only have one node.\n");
		return ;
	}	

	listNode*node=l->tail->prev;
	l->tail->prev->next=NULL;
	l->tail->next=l->head;
	l->head->prev=l->tail;
	l->head=l->tail;
	l->tail=node;
	l->head->prev=NULL;
}




int intMatch(void *ptr, void *key){
	int *a=(int *)ptr;
	int *b=(int *)key;
	return (*a==*b)?1:0;
}

void *intDup(void *ptr){
	return ptr;
}
int main(){
	printf("listCreate()\n");
	list*l=listCreate();
	printf("%d\n",l->len);
	listSetDupMethod(l,&intDup);

	int b=111;
	int *a=&b;
	l=listAddNodeHead(l,a);
	printf("%d\n",l->len);
	//使用void*指针的时候需要强制转换
	int *c=(int *)(l->head->value);
	printf("%d\n",*c);

	int bb=12;
	int *aa=&bb;
	l=listAddNodeHead(l,aa);
	//listInsertNode(l,l->head,a,1);
	//l=listAddNodeTail(l,aa);
	//printf("%d\n",l->len);
	//l=listDelNode(l,l->head);
	//l=listDelNode(l,l->tail);
	//printf("%d\n",l->len);
	listRotate(l);
	//使用void*指针的时候需要强制转换
	int *cc=NULL;
	listNode*temp=l->tail;
	while(temp){
		cc=(int *)(temp->value);
		printf("%d\n",*cc);
		temp=temp->prev;
	}
	
/*	list*l2=listDup(l);
	temp=l2->tail;
	while(temp){
		cc=(int *)(temp->value);
		printf("%d\n",*cc);
		temp=temp->prev;
	}
*/
	//listSetMatchMethod(l,&intMatch);
	listNode*node=listIndex(l,1);
	int *zhu=(int*)node->value;
	printf("*zhu:%d\n",*zhu);

	listRelease(l);
	//listRelease(l2);

	system("pause");
	return 0;
}
ShimmerPig
关注
专栏目录
list --双端队列结构。
qq_46611428的博客
09-24 104
先进后出，排序是按照插入的顺序排序比如:.沙和尚猪八戒孙悟空唐僧刘备关羽张飞赵四 左边增:lpush key xxx 右边增:rpush key xxx 遍历: lrange key 0 -1 左边删除:lpop key 右边删除:rpop key 插入 Linsert key Hero before “刘备” 查单 lindex hero 0 删除指定的值 比较复杂 lrem hero cout value count > 0 表示 从头向尾巴 从左到右 搜索 移除何 value 相等 元素， 数量
详细图文——双端链表
带翅膀的猫的博客
11-02 5327
前篇：单链表 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;双端链表与单链表十分相似，不同的是它新增一个对尾结点的引用。双端链表不是双向链表。 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;在单链表中在尾部插入一个结点需要一个个遍历到尾结点再插入，这样的效率太低了，使用双端链表就是否方便了。 实现代码 Link类： p
deque双端队列和普通list有什么不同
坚持的力量
07-12 845
想要从我deque中取数据，用列表切片的方法不行了，只能用itertools.islice，而且这个里边的索引号还不能是负数。 itertools.islice(historylist, 3 ,81) 其他功能和列表一样，比如对双端列表求和，求长度； 我们看一下deque的所有方法 deque目前发现，除了切片不能够是像list那样，其他都和list一样，比如使用a[-1]这种用法， 通过对d...
数据结构-带头循环双向链表
m0_61245168的博客
09-28 258
学习了简单的单链表，我们继续学习结构稍复杂但有巨大优势的带头循环双向链表。
【数据结构】带头循环双链表的增删查改
Hamdh的博客
08-06 207
双链表是一种常用的数据结构，它可以在O(1)的时间复杂度下实现插入、删除和查找操作。双链表中的每个节点都包含一个指向前一个节点和后一个节点的指针，这样可以方便地在任意位置进行插入和删除操作。
redis 源代码
06-05
redis源代码+注释 redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都...
Redis源代码分析.pdf
09-13
Redis源代码分析 Redis是一款开源的Key-Value存储引擎，支持多种值类型，如string、hash、list、set和sorted set等。 Redis源代码分析文档对Redis的源代码进行了深入分析，涵盖了Redis的基本功能、服务器模型、事件...
redis_analyze:redis源代码分析-redis source code
03-25
在深入分析Redis源代码的过程中，我们可以理解其内部工作原理，优化性能，甚至为自定义功能打下基础。以下是对Redis源代码的一些关键知识点的详细解析。 1. **Redis的数据结构** Redis的核心在于它高效的数据结构...
redis:redis源代码+学习笔记
03-23
本文将深入探讨Redis的源代码和学习笔记，帮助读者更好地理解和应用这个强大的系统。 Redis的源代码结构清晰，采用C语言编写，使得它在内存效率和性能上表现出色。源码中包含的主要部分有： 1. **src** 目录：这是...
最全面的Redis应用代码
03-28
5. Carlson_Redis_sourcecode.zip可能包含了Redis的源代码，这为深入理解Redis内部工作原理提供了机会。你可以研究它的数据结构实现、命令处理流程、网络通信模块以及持久化机制等内容，这对于进阶学习和优化Redis...
数据结构-链表（C语言+动态内存管理）
weixin_72501602的博客
05-08 665
无哨兵位单链表
【leetcode】单链表题集
xiaoshe的专栏
05-13 300
1，反转单链表 来源：206. 反转链表 &&剑指 Offer 24. 反转链表 迭代思路：采用头插法创建一个新的单链表。时间复杂度O(N)，空间复杂度O(1)。 class Solution { public: ListNode* reverseList(ListNode* head) { ListNode *result = NULL; while (head) { ListNode *next = head-...
真正的入门——链表
qq_56713382的博客
12-01 320
不知道各位有没有看过一部国漫——《刺客伍六七》。在我这个血统并不算纯的二次元来说，这部动漫无论从剧情还是打斗等各个方面，都可以算的上是动漫中的一流作品了。/*仅仅在我看过的动漫中*/ 当然这篇博客的主题肯定不是来讲动漫的。我们今天的主题正如标题所言，是数据结构的一大地基——链表。在我的见闻中，链表此物，与刺客伍六七中主角阿柒的“专武”——神锻国国宝——魔刀千刃，有着异曲同工之妙。与普通的刀剑（顺序表）不同，魔刀千刃（链表）由一片片碎片组成，可以随主人的心意作为一个整体的刀或分解为一个个碎片来进攻敌人，号称
数据结构之[双链表的是实现]【保姆级讲解】
cls的博客
10-23 492
上篇文章我们实现了链表中两大重要链表之一无头单项非循环链表，这次我们来实现带头双向循环链表。 话不多说上图： 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向 循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而 简单了，后面我们代码实现了就知道了。 废话不多说我们进入正题： 进行带头双向循环链表的实现 根据上图我们可以看出，该链表需要存储两个指针，所以我们在定义的时候就需要一前一后俩指...
步步为营（八）常用数据结构（1）STL-List（双端链表）
Kernight
07-28 923
额，这个真的有必要说么~~ 链表是空间动态分配的，内存不连续，不能随机进行访问和储存的结构。 链表的存储方式注定了链表在查找时面临着O(n)的时间复杂度，虽然看起来不算很大，但是这是单次查找的复杂度，如果要进行稍微复杂一点的操作，复杂度便很可能会飙升到O(n^2)，这个复杂度真的会死人的……不过链表的优点也很明显，如果程序对随机存储（也可以理解为下标式操作）的效率要求不高，那么使用链表存储数据比
【Redis】在java中的使用-存取list类型（附源码）
玫瑰与鹿°
11-03 1万+
我们知道，Redis一共有5种数据类型，前几天小编总结了string类型的使用。今天来说说list类型的。 Redis里面存储的类型是key-value型的，本文的例子中key为a，value为5、1、4、2、3。 在客户端的操作 我们先看看在客户端，如果想查询a中的值要怎么操作。以下3个操作实现的功能为： 查询a中的值 将a中的值排序后正序输出 将a中的值排序后降序输出 在java代码中的...
Java实现Redis的列表（List）命令
热门推荐
qq_41934990的博客
08-13 1万+
配置文件请看Java实现redis  https://blog.csdn.net/qq_41934990/article/details/81612180 注释里面的代码是linux中redis命令 package com.huadian.list; import com.huadian.redisUntil.JedisPoolUntil; import org.junit.Before;...
Java代码实现Redis的CRUD
Tang的博客
03-26 2693
上一篇文章，介绍了在Linux系统下如何安装Redis；接下来介绍如何在Java中使用Redis来实现数据存储和查询。1.首先，修改配置文件，将其修改为可以远程链接：vi /etc/redis/redis.conf（/etc/redis 是在线安装时默认的安装目录）可能因为权限问题无法编辑，可以使用以下命令进行升权，使用管理员权限进行操作：sudo passwd密码：&lt;--- 输入安装时那个...
C# + SQLiteExpert 进行（cipher）加密数据库开发+Costura.Fody 清爽发布
最新发布
PeerLessSoul
09-27 1078
SQLiteExpert 作为SQlite 的管理工具，默认不支持加密数据库的，使其成为支持（cipher）加密数据库的管理工具，需要添加e_sqlcipher.dll （复制到SQLiteExpertPro32/64.exe 同级目录即可，从哪里来的这个问题：你可以直接往后面下载链接下，也可以跟随文章知道从哪里来的。debug 生成的很多，也就是刚才说的发布生成洁癖的问题，如果你在意，发布时候选择输出好平台，runtime可以自动减少，但是依旧会生成其他dll。其他乱七八糟的dll没有了，清爽吧？
Redis源代码分析：数据结构与服务器模型
在Redis源代码分析中，我们首先了解到Redis是一个开源的Key-Value存储系统，它支持多种数据类型，包括string、hash、list、set和sorted set。接下来，文档深入到Redis的核心数据结构和功能： 2.1. 链表(adlist.h/...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值